make -C src build BUILDDIR=/data1/sunzhq/rccl-tests-develop/build
make[1]: Entering directory '/data1/sunzhq/rccl-tests-develop/src'
Compiling  timer.cc                            > /data1/sunzhq/rccl-tests-develop/build/timer.o
Compiling /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o
Compiling  all_reduce.cu                       > /data1/sunzhq/rccl-tests-develop/build/all_reduce.o
Compiling  common.cu                           > /data1/sunzhq/rccl-tests-develop/build/common.o
 /opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c ../verifiable/verifiable.cu
Compiling  all_gather.cu                       > /data1/sunzhq/rccl-tests-develop/build/all_gather.o
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/all_reduce.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c all_reduce.cu
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/common.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c common.cu
Compiling  broadcast.cu                        > /data1/sunzhq/rccl-tests-develop/build/broadcast.o
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/all_gather.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c all_gather.cu
Compiling  reduce_scatter.cu                   > /data1/sunzhq/rccl-tests-develop/build/reduce_scatter.o
Compiling  reduce.cu                           > /data1/sunzhq/rccl-tests-develop/build/reduce.o
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/broadcast.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c broadcast.cu
Compiling  alltoall.cu                         > /data1/sunzhq/rccl-tests-develop/build/alltoall.o
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/reduce_scatter.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c reduce_scatter.cu
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/reduce.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c reduce.cu
Compiling  scatter.cu                          > /data1/sunzhq/rccl-tests-develop/build/scatter.o
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/alltoall.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c alltoall.cu
Compiling  gather.cu                           > /data1/sunzhq/rccl-tests-develop/build/gather.o
Compiling  sendrecv.cu                         > /data1/sunzhq/rccl-tests-develop/build/sendrecv.o
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/scatter.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c scatter.cu
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/gather.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c gather.cu
Compiling  alltoallv.cu                        > /data1/sunzhq/rccl-tests-develop/build/alltoallv.o
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/sendrecv.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c sendrecv.cu
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/alltoallv.o -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi -c alltoallv.cu
sendrecv.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
sendrecv.cu:50:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:51:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
sendrecv.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:69:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
sendrecv.cu:78:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
sendrecv.cu:50:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
sendrecv.cu:78:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:80:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoall.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoall.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoall.cu:70:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce.cu:64:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:70:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:80:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:106:49: warning: 'sscanf' may overflow; destination buffer in argument 4 has size 1, but the corresponding specifier may require size 2 [-Wfortify-source]
    int count = sscanf(value, "%lf %1s", &size, &size_lit);
                                                ^
all_reduce.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:210:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_reduce.cu:65:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:850:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:27:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:89:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:926:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:170:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:410:14: warning: enumeration value 'ncclNumTypes' not handled in switch [-Wswitch]
      switch(type) {
             ^~~~
alltoallv.cu:27:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:89:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:170:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:85:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx906.
3 warnings generated when compiling for gfx928.
common.cu:629:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx906.
all_reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_reduce.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_reduce.cu:65:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:27:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx926.
gather.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:89:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:51:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:69:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:170:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:85:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
33 warning warningss generated generated when compiling for  when compiling for gfx928gfx906.
.
3 warnings generated when compiling for gfx926.
3 warnings generated when compiling for gfx906.
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
sendrecv.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3../verifiable/verifiable.cu: warning612s: generated1 when compiling for :gfx926 .
warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
sendrecv.cu:50:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx906.
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
sendrecv.cu:78:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
gather.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
gather.cu:85:1:  case ncclSum: CASE_OP(ReduceSum()) 
warning:                 ^void function is missing a return statement [-Wreturn-type]

../verifiable/verifiable.cu}:
833^:
7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx926.
3 warnings generated when compiling for gfx926.
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:427:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:453:3: note: in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned int>' requested here
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
  ^
../verifiable/verifiable.cu:632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<__half>' requested here
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);
        ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx906.
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx928.
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:427:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:453:3: note: in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned long>' requested here
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
  ^
../verifiable/verifiable.cu:632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<double>' requested here
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);
        ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx928.
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
alltoall.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu:577:1}:
 ^warning: 
void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
common.cu:269:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:524:3: note: in instantiation of function template specialization 'Allreduce<double>' requested here
  Allreduce(args, &deltaSec, average);
  ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx906.
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7common.cu:: 269note: :expanded from macro 'CASE_OP'1
: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:593:7: note: in instantiation of function template specialization 'Allreduce<long long>' requested here
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
      Allreduce(args, &wrongElts1, /*sum*/4);
      ^
alltoall.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
alltoall.cu:70:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx926.
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx928.
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
broadcast.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
broadcast.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
6 warnings generated when compiling for gfx926.
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
broadcast.cu:74:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
broadcast.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
broadcast.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx928.
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
broadcast.cu  ^:
74:1:../verifiable/verifiable.cu :warning: 791void function is missing a return statement [-Wreturn-type]:
15}:
 ^note: 
in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
all_gather.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu}:
706^:
1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
all_gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
broadcast.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})all_gather.cu:
70                ^:
1: ../verifiable/verifiable.cuwarning: :void function is missing a return statement [-Wreturn-type]835
:7}:
 ^note: 
expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
reduce.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
broadcast.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce.cu:64:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
broadcast.cu:74:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx926.
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
reduce.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce.cu:64:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
reduce_scatter.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
reduce_scatter.cu:51:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:69:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx928.
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:9143:17 warning:s  generatednote:  when compiling for in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested heregfx906
.
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx906.
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
common.cu:106:49: warning: 'sscanf' may overflow; destination buffer in argument 4 has size 1, but the corresponding specifier may require size 2 [-Wfortify-source]
    int count = sscanf(value, "%lf %1s", &size, &size_lit);
                                                ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx906.
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
common.cu:210:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
common.cu:410:14: warning: enumeration value 'ncclNumTypes' not handled in switch [-Wswitch]
      switch(type) {
             ^~~~
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx926.
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
common.cu:629:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx926.
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
../verifiable/verifiable.cu:850  case ncclMax: CASE_OP(ReduceMax()):
1                ^:
 warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
911:7: note: expanded from macro 'CASE_OP'}

^
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:926:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
common.cu:106:49: warning: 'sscanf' may overflow; destination buffer in argument 4 has size 1, but the corresponding specifier may require size 2 [-Wfortify-source]
all_reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
    int count = sscanf(value, "%lf %1s", &size, &size_lit);
                                                ^
all_reduce.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
common.cu}
:^210
:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_reduce.cu:65:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
all_gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
all_gather.cu:70:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
common.cu:410:14: warning: enumeration value 'ncclNumTypes' not handled in switch [-Wswitch]
      switch(type) {
             ^~~~
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
../verifiable/verifiable.cu  ^
:850:../verifiable/verifiable.cu1::868 :15warning: : void function is missing a return statement [-Wreturn-type]note: 
in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd>' requested here
}
^
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:926:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
common.cu:629:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}../verifiable/verifiable.cu
^:
799:1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu:}770
:^3
: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:  case ncclUint8: CASE_TY(uint8_t)15
:                  ^ 
note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceProd>' requested here
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
../verifiable/verifiable.cu                     ^:
883:22: note: ../verifiable/verifiable.cuexpanded from macro 'CASE_TY':
838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)../verifiable/verifiable.cu
                    ^:
612:../verifiable/verifiable.cu1::883 :warning: 22void function is missing a return statement [-Wreturn-type]:
 note: expanded from macro 'CASE_TY'
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, true>' requested here
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
  genInput(ans, op, rank_n, rank_me, seed, index,../verifiable/verifiable.cu
:  ^917
:18: note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here:
791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, true>' requested here
../verifiable/verifiable.cu:875:1:  genInput(ans, op, rank_n, rank_me, seed, index, 
warning:   ^void function is missing a return statement [-Wreturn-type]

../verifiable/verifiable.cu}:
791^:
15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceNil>' requested here
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
  case ncclInt8: CASE_TY(int8_t)../verifiable/verifiable.cu
:                 ^812
:20../verifiable/verifiable.cu:: 883note: :in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here22
: note: expanded from macro 'CASE_TY'
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})../verifiable/verifiable.cu
:                ^838
:../verifiable/verifiable.cu17::911 :note: 7in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here:
 note: expanded from macro 'CASE_OP'
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \

^      ^

../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^612
:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
common.cu:269:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:524:3: note: in instantiation of function template specialization 'Allreduce<double>' requested here
  Allreduce(args, &deltaSec, average);
  ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
common.cu:269:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:593:7: note: in instantiation of function template specialization 'Allreduce<long long>' requested here
      Allreduce(args, &wrongElts1, /*sum*/4);
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx928.
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:427:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:453:3: note: in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned int>' requested here
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
  ^
../verifiable/verifiable.cu:632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<__half>' requested here
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);
        ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
3 warnings generated when compiling for gfx928.
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \799
:      ^1
: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
scatter.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;}

^                     ^

../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
alltoall.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:717:2:  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break; 
warning:                      ^void function is missing a return statement [-Wreturn-type]

../verifiable/verifiable.cu: }838
: ^17
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here  case ncclSum: CASE_OP(ReduceSum())

                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceAvg>' requested here
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
scatter.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
alltoall.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
alltoall.cu:70:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
scatter.cu:../verifiable/verifiable.cu80::1799:: 1warning: :void function is missing a return statement [-Wreturn-type] 
warning: void function is missing a return statement [-Wreturn-type]
}}

^^

../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
6 warnings generated when compiling for gfx906.
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:427:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:453:3: note: in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned long>' requested here
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
  ^
../verifiable/verifiable.cu:632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<double>' requested here
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);
        ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:577:1:  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break; 
warning:                      ^void function is missing a return statement [-Wreturn-type]

../verifiable/verifiable.cu}:
922^:
12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin, void>' requested here  default: CASE_OP(ReducePreMulSum())

           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin>' requested here
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu../verifiable/verifiable.cu::594810::119::  warning: note: void function is missing a return statement [-Wreturn-type]in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here

}
^
  case ncclUint8: CASE_TY(uint8_t)../verifiable/verifiable.cu
:                  ^770
:3: note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum, true>' requested here:
807:22: note: expanded from macro 'CASE_TY'
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);839
:              ^17
: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here888
:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
  case ncclUint32: CASE_TY(uint32_t)../verifiable/verifiable.cu
:                   ^835
:7: ../verifiable/verifiable.cunote: :expanded from macro 'CASE_OP'883
:22: note: expanded from macro 'CASE_TY'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
../verifiable/verifiable.cu:799  default: CASE_OP(ReducePreMulSum()):
1           ^:
 warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
911:7:} 
note: ^expanded from macro 'CASE_OP'

../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum, true>' requested here
../verifiable/verifiable.cu  genOutput(ans, op, rank_n, seed, index,:
577  ^:
1:../verifiable/verifiable.cu :warning: 868void function is missing a return statement [-Wreturn-type]:
15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here}

^
../verifiable/verifiable.cu:    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);760
:              ^3
: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin, void>' requested here../verifiable/verifiable.cu
:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
  case ncclUint64: CASE_TY(uint64_t)../verifiable/verifiable.cu
:                   ^791
:15../verifiable/verifiable.cu:: 883note: :in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin>' requested here22
: note: expanded from macro 'CASE_TY'
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
  case ncclInt64: CASE_TY(int64_t)
../verifiable/verifiable.cu                  ^:
922:12:../verifiable/verifiable.cu :note: 807in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here:
22: note: expanded from macro 'CASE_TY'
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \839
:      ^17
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
../verifiable/verifiable.cu:  default: CASE_OP(ReducePreMulSum())799
:           ^1
: warning: void function is missing a return statement [-Wreturn-type]../verifiable/verifiable.cu
:911}:
7^
: note: expanded from macro 'CASE_OP'../verifiable/verifiable.cu
:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^807
:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;../verifiable/verifiable.cu
:                     ^875
:1: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
839:17: note: }in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here

^
../verifiable/verifiable.cu  case ncclMin: CASE_OP(ReduceMin()):
893                ^:
22: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here835
:7: note: expanded from macro 'CASE_OP'
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
../verifiable/verifiable.cu:  case ncclBfloat16: CASE_TY(hip_bfloat16)693
                     ^:
1: ../verifiable/verifiable.cuwarning: :void function is missing a return statement [-Wreturn-type]807
:}22
:^ 
note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;  genOutput(ans, op, rank_n, seed, index,

                     ^
  ^
../verifiable/verifiable.cu:839:17../verifiable/verifiable.cu:: 868note: :in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here15
: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \22
:      ^ 
note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
../verifiable/verifiable.cu:875:1: warning:   case ncclMin: CASE_OP(ReduceMin())void function is missing a return statement [-Wreturn-type]

                ^
../verifiable/verifiable.cu:}835
:^7
: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \  case ncclFloat32: CASE_TY(float)

      ^                    ^

../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]
:693:1: warning: void function is missing a return statement [-Wreturn-type]}

^
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here:
746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:729:3: ../verifiable/verifiable.cunote: :  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here883
:
                     ^22
: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833  genInput(ans, op, rank_n, rank_me, seed, index,:  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
7
  ^                     ^:
 
note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu../verifiable/verifiable.cu::791922::1512::  note: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested herein instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here

      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
  default: CASE_OP(ReducePreMulSum())
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);           ^

              ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::911817::227::  note: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
expanded from macro 'CASE_OP'
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;../verifiable/verifiable.cu
:                     ^875
:1: ../verifiable/verifiable.cuwarning: :void function is missing a return statement [-Wreturn-type]839
:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here}

^
../verifiable/verifiable.cu  case ncclMin: CASE_OP(ReduceMin()):
896                ^:
21: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here../verifiable/verifiable.cu835
::6127::1   case ncclFloat64: CASE_TY(double):
 note:                     ^warning: 
expanded from macro 'CASE_OP'void function is missing a return statement [-Wreturn-type]

../verifiable/verifiable.cu:883:22: note: }expanded from macro 'CASE_TY'

^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^760
:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, true>' requested here  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;

                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^  default: CASE_OP(ReducePreMulSum())

           ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::791911::157::  note: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceNil>' requested hereexpanded from macro 'CASE_OP'

      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);

      ^
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu}:
730^:
1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu}:
770^:
3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here../verifiable/verifiable.cu
:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReducePreMulSum>' requested here  genInput(ans, op, rank_n, rank_me, seed, index,

  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21  case ncclFloat64: CASE_TY(double):
                     ^note: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
../verifiable/verifiable.cu:883:22:   case ncclFloat32: CASE_TY(float)note: 
expanded from macro 'CASE_TY'                    ^

../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;922
:                     ^12
: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here../verifiable/verifiable.cu
:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu  case ncclMin: CASE_OP(ReduceMin()):
911                ^:
7:../verifiable/verifiable.cu :note: 835expanded from macro 'CASE_OP':
7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
../verifiable/verifiable.cu^:
746:1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu}:
810^:
19: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here729
:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);:
22  ^:
 note: expanded from macro 'CASE_TY'../verifiable/verifiable.cu
:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^../verifiable/verifiable.cu
:838:17../verifiable/verifiable.cu:: 819note: :in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here21
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclSum: CASE_OP(ReduceSum())  case ncclFloat32: CASE_TY(float)

                ^                    ^

../verifiable/verifiable.cu../verifiable/verifiable.cu::807833::227::  note: note: expanded from macro 'CASE_TY'expanded from macro 'CASE_OP'

  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \                     ^

      ^
../verifiable/verifiable.cu../verifiable/verifiable.cu:839::101517::1 :note:  in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested herewarning: 
void function is missing a return statement [-Wreturn-type]
}
  case ncclMin: CASE_OP(ReduceMin())^

                ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::8351107::718::  note: note: expanded from macro 'CASE_OP'in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned char>' requested here

  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^1101
:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
common.cu:269:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:524:3: note: in instantiation of function template specialization 'Allreduce<double>' requested here
  Allreduce(args, &deltaSec, average);
  ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cucommon.cu::  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;269
799:                     ^:11
::  ../verifiable/verifiable.cuwarning: warning: :void function is missing a return statement [-Wreturn-type]void function is missing a return statement [-Wreturn-type]839
:
17:} }

note: ^^in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here


common.cu:593:7: note: in instantiation of function template specialization 'Allreduce<long long>' requested here  case ncclMin: CASE_OP(ReduceMin())

../verifiable/verifiable.cu                ^:
811:../verifiable/verifiable.cu19::      Allreduce(args, &wrongElts1, /*sum*/4);835
:       ^7
:note:  in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested herenote: 
expanded from macro 'CASE_OP'
  case ncclInt32: CASE_TY(int32_t)
                  ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^807
:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)../verifiable/verifiable.cu
                 ^:
612:1:../verifiable/verifiable.cu :warning: 807void function is missing a return statement [-Wreturn-type]:
22: note: expanded from macro 'CASE_TY'
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, true>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
  case ncclMax: CASE_OP(ReduceMax())../verifiable/verifiable.cu
:                ^791
:15:../verifiable/verifiable.cu :note: 835in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceNil>' requested here:
7: note: expanded from macro 'CASE_OP'
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \              ^

      ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^  case ncclMin: CASE_OP(ReduceMin())

                ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu1061::8385::17 :note:  expanded from macro 'CASE_OP'note: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:833:7: note: ../verifiable/verifiable.cuexpanded from macro 'CASE_OP':
1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \

      ^
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu../verifiable/verifiable.cu::799760::13::  warning: note: void function is missing a return statement [-Wreturn-type]in instantiation of function template specialization '(anonymous namespace)::genInput<long, true>' requested here

}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::791807::1522::  note: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceNil>' requested hereexpanded from macro 'CASE_TY'

    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;              ^

                     ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::813840::1917::  note: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested herein instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here

  case ncclMax: CASE_OP(ReduceMax())
                ^
  case ncclInt64: CASE_TY(int64_t)../verifiable/verifiable.cu
:                  ^835
:7../verifiable/verifiable.cu:: 807note: :../verifiable/verifiable.cuexpanded from macro 'CASE_OP'22::
1049 :note: 1expanded from macro 'CASE_TY':
 warning: void function is missing a return statement [-Wreturn-type]
}
^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^../verifiable/verifiable.cu
:1061:5: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu833::11037::9 :note:  expanded from macro 'CASE_OP'note: 
expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \

        ^      ^

../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::7991049::11: :warning:  void function is missing a return statement [-Wreturn-type]warning: 
void function is missing a return statement [-Wreturn-type]
}
^}

^
../verifiable/verifiable.cu../verifiable/verifiable.cu::8141070::2017: :note:  in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested herenote: 
in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})                   ^

                ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu807::106122::5 :note:  expanded from macro 'CASE_TY'note: 
expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;

                     ^
../verifiable/verifiable.cu:838:17:   case ncclInt8: CASE_TY(int8_t, uint8_t)note: 
                 ^in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here

../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \^

    ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::7601107:3::18 note: :in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, true>' requested here 
note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu  case ncclInt8: CASE_TY(int8_t, uint8_t)../verifiable/verifiable.cu:
:791                 ^577:
:151:../verifiable/verifiable.cu ::note:  in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceNil>' requested here1103warning: 
:void function is missing a return statement [-Wreturn-type]9
: note: }expanded from macro 'CASE_TY'

^
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);../verifiable/verifiable.cu
:              ^760
:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax, void>' requested here
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \../verifiable/verifiable.cu
:  case ncclUint64: CASE_TY(uint64_t)        ^791

:                   ^15
: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note:   #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;expanded from macro 'CASE_TY'

                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:840:../verifiable/verifiable.cu17::833 :note: 7in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here:
 note: expanded from macro 'CASE_OP'
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \

      ^      ^

../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::1049799::1:1 :warning:  void function is missing a return statement [-Wreturn-type]warning: 
void function is missing a return statement [-Wreturn-type]
}
^
}
^
../verifiable/verifiable.cu:1067:17: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMax>' requested here817
:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \807
:    ^22
: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \:
17        ^:
 note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^612
:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
../verifiable/verifiable.cu        ^
:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::612799::11::  warning: warning: void function is missing a return statement [-Wreturn-type]void function is missing a return statement [-Wreturn-type]

}
^}

^
../verifiable/verifiable.cu:760:../verifiable/verifiable.cu3::810 :note: 19in instantiation of function template specialization '(anonymous namespace)::genInput<double, false>' requested here:
 note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
  genInput(ans, op, rank_n, rank_me, seed, index,../verifiable/verifiable.cu
:  ^807
:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceNil>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);../verifiable/verifiable.cu
:              ^841
:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here  case ncclProd: CASE_OP(ReduceProd())

                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22:      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \ 
note:       ^expanded from macro 'CASE_TY'

  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:../verifiable/verifiable.cu9: :note: 577expanded from macro 'CASE_TY':
1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd, void>' requested here
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:1049:1:   #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;warning: 
                     ^void function is missing a return statement [-Wreturn-type]

../verifiable/verifiable.cu:841}:18
:^ note: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())../verifiable/verifiable.cu
:                 ^
1065:../verifiable/verifiable.cu17:835:: 7:note:  in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceNil>' requested herenote: 
expanded from macro 'CASE_OP'
  case ncclSum: CASE_OP(ReduceSum())
                ^      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \

      ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
6 warnings generated when compiling for gfx928.
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
../verifiable/verifiable.cu:  case ncclUint32: CASE_TY(uint32_t)799
:                   ^1
:../verifiable/verifiable.cu :warning: 807void function is missing a return statement [-Wreturn-type]:
22: note: expanded from macro 'CASE_TY'
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18:   case ncclInt8: CASE_TY(int8_t)note: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here                 ^

../verifiable/verifiable.cu:807:22:  case ncclProd: CASE_OP(ReduceProd()) 
note:                  ^expanded from macro 'CASE_TY'

../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19:../verifiable/verifiable.cu :note: 1049in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here:
1: warning: void function is missing a return statement [-Wreturn-type]
}  case ncclInt64: CASE_TY(int64_t)

^                  ^

../verifiable/verifiable.cu:807:22../verifiable/verifiable.cu:: 1067note: :expanded from macro 'CASE_TY'17
: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \

    ^
../verifiable/verifiable.cu:1109  case ncclProd: CASE_OP(ReduceProd()):
19                 ^:
 note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here../verifiable/verifiable.cu
:835:7: note: expanded from macro 'CASE_OP'
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;

                     ^
}
../verifiable/verifiable.cu^:
841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
../verifiable/verifiable.cu:1068:18:  case ncclProd: CASE_OP(ReduceProd()) 
note:                  ^in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceProd>' requested here

../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
  case ncclProd: CASE_OP(ReduceProd())
                 ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^1061
:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: ../verifiable/verifiable.cuwarning: :void function is missing a return statement [-Wreturn-type]814
:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here}

^
  case ncclUint64: CASE_TY(uint64_t)../verifiable/verifiable.cu
:                   ^810
:19: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here807
:22: note: expanded from macro 'CASE_TY'
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22:   #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;note: 
expanded from macro 'CASE_TY'                     ^

../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \:
838      ^:
17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
33 warning warningss generated generated when compiling for  when compiling for gfx926gfx928.
.
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu807::22577:: 1note: :expanded from macro 'CASE_TY' 
warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;3
:                     ^ 
note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum, void>' requested here../verifiable/verifiable.cu
:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
  genInput(ans, op, rank_n, rank_me, seed, index,../verifiable/verifiable.cu
:  ^835
:7: note: ../verifiable/verifiable.cuexpanded from macro 'CASE_OP':
791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::791:104915:1::  note: warning: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum>' requested here
void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);1067
              ^:
17: note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMax>' requested here:
813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu1061::8075::22 :note:  expanded from macro 'CASE_OP'note: 
expanded from macro 'CASE_TY'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^  case ncclUint32: CASE_TY(uint32_t, uint32_t)

                   ^
../verifiable/verifiable.cu:1103:9../verifiable/verifiable.cu:: 838note: :expanded from macro 'CASE_TY'17
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5../verifiable/verifiable.cu: note: :expanded from macro 'CASE_OP'799
:1: warning: void function is missing a return statement [-Wreturn-type]
}    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \

^    ^

../verifiable/verifiable.cu:1110:20: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here814
:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note:   case ncclUint64: CASE_TY(uint64_t)expanded from macro 'CASE_TY'

                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
../verifiable/verifiable.cu:  case ncclFloat64: CASE_TY(double)1049
:                    ^1
: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
807:22:} 
note: ^expanded from macro 'CASE_TY'

../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note:   case ncclAvg: CASE_OP(ReduceAvg{rank_n})in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here

                ^
../verifiable/verifiable.cu:1061  case ncclProd: CASE_OP(ReduceProd()):
5                 ^:
../verifiable/verifiable.cu../verifiable/verifiable.cu: :577note: :835expanded from macro 'CASE_OP'1
::7 :warning:  void function is missing a return statement [-Wreturn-type]note: 
expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
}    ^

^
../verifiable/verifiable.cu:1110../verifiable/verifiable.cu::20760      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \::
3 :note:       ^ in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
note: 
in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum, void>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
  genInput(ans, op, rank_n, rank_me, seed, index,                   ^

  ^
../verifiable/verifiable.cu:1103../verifiable/verifiable.cu::9791::15 : note: note: expanded from macro 'CASE_TY'in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum>' requested here

    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \:
799        ^:
1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \}

        ^^

../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'../verifiable/verifiable.cu
:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;17
:                     ^
 note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceNil>' requested here../verifiable/verifiable.cu
:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5:  case ncclAvg: CASE_OP(ReduceAvg{rank_n}) 
note:                 ^expanded from macro 'CASE_OP'

../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19:      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \ 
note:       ^in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here

  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::7991111::119::  warning: void function is missing a return statement [-Wreturn-type]note: 
in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
}
^
../verifiable/verifiable.cu  case ncclInt64: CASE_TY(int64_t, uint64_t):
812                  ^:
20: note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here:
1103:9: note: expanded from macro 'CASE_TY'
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \

                     ^        ^

../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:427../verifiable/verifiable.cu::1577:: 1warning:         verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \:void function is missing a return statement [-Wreturn-type]
 
        ^warning: 
void function is missing a return statement [-Wreturn-type]}

^
}
^
../verifiable/verifiable.cu:453../verifiable/verifiable.cu::3760:: 3note: :in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned int>' requested here 
note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
../verifiable/verifiable.cu  ^:
791:15: note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg>' requested here:
632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<__half>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);../verifiable/verifiable.cu
:        ^807
:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;  genInput(ans, op, rank_n, rank_me, seed, index,

                     ^  ^

../verifiable/verifiable.cu:843:../verifiable/verifiable.cu17::791 :note: 15in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here:
 note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21:       prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \note: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here      ^

  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
../verifiable/verifiable.cu                     ^
:1049../verifiable/verifiable.cu::1843:: 17warning: :void function is missing a return statement [-Wreturn-type] 
note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
}
^
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::8351070::717::  note: note: expanded from macro 'CASE_OP'in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here

  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \                ^

      ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^}

^
../verifiable/verifiable.cu:807:22: ../verifiable/verifiable.cunote: :expanded from macro 'CASE_TY'815
:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;838
:                     ^17
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here../verifiable/verifiable.cu
:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^  case ncclAvg: CASE_OP(ReduceAvg{rank_n})

                ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::835835::77::  note: note: expanded from macro 'CASE_OP'expanded from macro 'CASE_OP'

      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
:                     ^1049
:1: warning: void function is missing a return statement [-Wreturn-type]
}../verifiable/verifiable.cu
:^838
:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
  case ncclMin: CASE_OP(ReduceMin())
                ^../verifiable/verifiable.cu
:835:7../verifiable/verifiable.cu:: 1061note: :expanded from macro 'CASE_OP'5
: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20:      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \ 
note:       ^in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here

  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
633:1:} 
warning: ^void function is missing a return statement [-Wreturn-type]

../verifiable/verifiable.cu}:
760^:
3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceAvg>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);../verifiable/verifiable.cu
:              ^791
:15: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceSum>' requested here819:
21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);:
22              ^:
../verifiable/verifiable.cu :note: 1049expanded from macro 'CASE_TY'../verifiable/verifiable.cu:
1::819 :warning: void function is missing a return statement [-Wreturn-type]21
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here}

^
../verifiable/verifiable.cu  case ncclFloat32: CASE_TY(float):  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
1067
                    ^:                     ^
17
: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMax>' requested here../verifiable/verifiable.cu../verifiable/verifiable.cu
::807843::22  case ncclMax: CASE_OP(ReduceMax())17:
 :note:                 ^ expanded from macro 'CASE_TY'

note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here../verifiable/verifiable.cu
:1061:5: note: expanded from macro 'CASE_OP'
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note:     verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \expanded from macro 'CASE_OP'

    ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;../verifiable/verifiable.cu
:1112                     ^:
20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
../verifiable/verifiable.cu:      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \838
:      ^17  case ncclUint64: CASE_TY(uint64_t, uint64_t):

                    ^note: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu:1049}:
1^:
 warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:../verifiable/verifiable.cu820::107321::12:  note: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested herein instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here

  default: CASE_OP(ReducePreMulSum())  case ncclFloat64: CASE_TY(double)

           ^                    ^

../verifiable/verifiable.cu../verifiable/verifiable.cu::1061807:5::22 :note:  expanded from macro 'CASE_OP'note: 
expanded from macro 'CASE_TY'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;../verifiable/verifiable.cu
:1103                     ^:
9: note: ../verifiable/verifiable.cuexpanded from macro 'CASE_TY':
838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \835
:        ^7
: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'../verifiable/verifiable.cu
:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:427:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:453:3: note: in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned long>' requested here
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
  ^
../verifiable/verifiable.cu:632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<double>' requested here
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);
        ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
:    ^675
:../verifiable/verifiable.cu1::1113 :warning: 21void function is missing a return statement [-Wreturn-type]:
 note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
}
^
../verifiable/verifiable.cu:760  case ncclFloat16: CASE_TY(__half, uint16_t):
3                    ^:
 note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::genInput<int>' requested here:
1103:9: note: expanded from macro 'CASE_TY'
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReducePreMulSum>' requested here
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \../verifiable/verifiable.cu
      ^:
1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMin>' requested here../verifiable/verifiable.cu
:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \835
:    ^7
: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu791:15::577 :note: 1in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here:
 warning: void function is missing a return statement [-Wreturn-type]
}
^
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here760
:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin, void>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
  default: CASE_OP(ReducePreMulSum())../verifiable/verifiable.cu
:           ^809
:18../verifiable/verifiable.cu:: 835note: :in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here7
: note: expanded from macro 'CASE_OP'
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \:
22      ^:
 note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807../verifiable/verifiable.cu::22799:: 1note: :expanded from macro 'CASE_TY' 
warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;19
:                     ^ 
note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here:
846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())  case ncclUint8: CASE_TY(uint8_t)

           ^                  ^

../verifiable/verifiable.cu:835../verifiable/verifiable.cu::7807:: 22note: :expanded from macro 'CASE_OP' 
note: expanded from macro 'CASE_TY'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
1049:1: warning: void function is missing a return statement [-Wreturn-type]}

^
}
^
../verifiable/verifiable.cu../verifiable/verifiable.cu::7601068::318::  note: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceProd>' requested herein instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin, void>' requested here

  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note:   genInput(ans, op, rank_n, rank_me, seed, index,expanded from macro 'CASE_OP'

  ^
../verifiable/verifiable.cu:791:15:     verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \note: 
in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin>' requested here    ^

../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);

../verifiable/verifiable.cu              ^:
1103:9: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \

        ^                  ^

../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \:
817      ^:
22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;:
577                     ^:
1: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here}

^
  default: CASE_OP(ReducePreMulSum())../verifiable/verifiable.cu
:           ^
760:../verifiable/verifiable.cu3::835 :note: 7in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin, void>' requested here:
 note: expanded from macro 'CASE_OP'
  genInput(ans, op, rank_n, rank_me, seed, index,
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \  ^

      ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
../verifiable/verifiable.cu:1077:  genInput(ans, op, rank_n, rank_me, seed, index,1
:  ^ 
warning: ../verifiable/verifiable.cu:void function is missing a return statement [-Wreturn-type]791
:15:} 
note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReducePreMulSum>' requested here^

../verifiable/verifiable.cu    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
:              ^1115
:22../verifiable/verifiable.cu:: 819note: :in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here21
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)../verifiable/verifiable.cu
:                     ^807
:22: note: expanded from macro 'CASE_TY'../verifiable/verifiable.cu
:1103:9: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \:
846        ^:
12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())../verifiable/verifiable.cu
:           ^577
:1../verifiable/verifiable.cu:: 835warning: :void function is missing a return statement [-Wreturn-type]7
: note: expanded from macro 'CASE_OP'}

^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin, void>' requested here      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \

      ^
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
1065:17:} 
note: ^in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceNil>' requested here

../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu  case ncclFloat64: CASE_TY(double):
1058                    ^:
5: note: expanded from macro 'CASE_OP'../verifiable/verifiable.cu
:807:22: note: expanded from macro 'CASE_TY'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note:   #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here

                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103  default: CASE_OP(ReducePreMulSum()):
9           ^:
 note: expanded from macro 'CASE_TY'../verifiable/verifiable.cu
:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,../verifiable/verifiable.cu
:  ^594
:1: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
791:}15
:^ 
note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil, true>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);  genOutput(ans, op, rank_n, seed, index,

  ^              ^

../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil>' requested here
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu  case ncclInt8: CASE_TY(int8_t):
807                 ^:
22../verifiable/verifiable.cu:: 883note: :expanded from macro 'CASE_TY'22
: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;914
:                     ^17
: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here  case ncclSum: CASE_OP(ReduceSum())

                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note:       prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \expanded from macro 'CASE_OP'

      ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here../verifiable/verifiable.cu
:1049:1: warning: void function is missing a return statement [-Wreturn-type]  case ncclInt32: CASE_TY(int32_t)

                  ^}

^
../verifiable/verifiable.cu:883:22:../verifiable/verifiable.cu :note: 1070expanded from macro 'CASE_TY':
17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;../verifiable/verifiable.cu
:                     ^1061
:5: note: ../verifiable/verifiable.cuexpanded from macro 'CASE_OP':
914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
  case ncclSum: CASE_OP(ReduceSum())    ^

                ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::9091115::722::  note: note: expanded from macro 'CASE_OP'
in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^1103
:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;

^                     ^

../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here../verifiable/verifiable.cu
:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here  case ncclSum: CASE_OP(ReduceSum())

                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \807
:      ^22
: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here817
:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22  case ncclBfloat16: CASE_TY(hip_bfloat16):
                      ^note: 
expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
  case ncclSum: CASE_OP(ReduceSum())                     ^

                ^
../verifiable/verifiable.cu:909:../verifiable/verifiable.cu7::839 :note: 17expanded from macro 'CASE_OP':
 note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^835
:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909../verifiable/verifiable.cu:7::799 :note: 1expanded from macro 'CASE_OP':
 warning: void function is missing a return statement [-Wreturn-type]
}
^
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \../verifiable/verifiable.cu
:    ^875
:1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu}:
1117^:
21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
  case ncclUint64: CASE_TY(uint64_t)                    ^

                   ^../verifiable/verifiable.cu
:1103:9../verifiable/verifiable.cu:: 883note: :expanded from macro 'CASE_TY'22: 
note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \../verifiable/verifiable.cu
:        ^914
:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil>' requested here
../verifiable/verifiable.cu    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
:              ^1049
:../verifiable/verifiable.cu1::890 :warning: 20void function is missing a return statement [-Wreturn-type]:
 note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
}
^
  case ncclUint64: CASE_TY(uint64_t)../verifiable/verifiable.cu
:                   ^1065
:17:../verifiable/verifiable.cu :note: 883in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceSum>' requested here:
22: note: expanded from macro 'CASE_TY'
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \17
:    ^ 
note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:  case ncclFloat32: CASE_TY(float, uint32_t)909
:                    ^7
: note: ../verifiable/verifiable.cuexpanded from macro 'CASE_OP':
1103:9: note: expanded from macro 'CASE_TY'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
:        ^875
:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu:809}:
^18
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:  case ncclFloat64: CASE_TY(double, uint64_t)807
:                    ^22
: note: ../verifiable/verifiable.cuexpanded from macro 'CASE_TY':
1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \1049
:      ^1
: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^577
:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:1049:1../verifiable/verifiable.cu:: 840warning: :void function is missing a return statement [-Wreturn-type]17
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here}

^
../verifiable/verifiable.cu:1067:17: note:   case ncclMax: CASE_OP(ReduceMax())in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMax>' requested here

                ^
../verifiable/verifiable.cu:835:  case ncclMax: CASE_OP(ReduceMax())7
:                ^ 
note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
../verifiable/verifiable.cu      ^:1118
:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu../verifiable/verifiable.cu:1061::7995:: 1note: :expanded from macro 'CASE_OP' 
warning: void function is missing a return statement [-Wreturn-type]
}
^
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu1118::81121::19 :note:  in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested herenote: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
  case ncclInt32: CASE_TY(int32_t)
../verifiable/verifiable.cu                  ^:
1103:9: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
../verifiable/verifiable.cu  case ncclInt32: CASE_TY(int32_t):
875                  ^:
1:../verifiable/verifiable.cu :warning: 807void function is missing a return statement [-Wreturn-type]:
22: note: }expanded from macro 'CASE_TY'

^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17:  case ncclMax: CASE_OP(ReduceMax()) 
note:                 ^in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here

../verifiable/verifiable.cu:835:  case ncclSum: CASE_OP(ReduceSum())7
:                ^ 
note: expanded from macro 'CASE_OP'../verifiable/verifiable.cu
:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \

      ^      ^

../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;:
799                     ^:
1: ../verifiable/verifiable.cuwarning: :void function is missing a return statement [-Wreturn-type]914
:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here}

^
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu909::8127::20 :note:  expanded from macro 'CASE_OP'note: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \

                   ^      ^

../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \

      ^
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;

                     ^
}
^
../verifiable/verifiable.cu:840../verifiable/verifiable.cu::17890:: 20note: :in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here 
note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
  case ncclMax: CASE_OP(ReduceMax())                   ^

                ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu883::83522::7 :note:  expanded from macro 'CASE_TY'note: 
expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
../verifiable/verifiable.cu      ^:
914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
  genOutput(ans, op, rank_n, seed, index,
  ^../verifiable/verifiable.cu
:841:18../verifiable/verifiable.cu:: 868note: :in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here15
: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
../verifiable/verifiable.cu              ^:
835:7: ../verifiable/verifiable.cunote: :891expanded from macro 'CASE_OP':
21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]  case ncclUint32: CASE_TY(uint32_t)

                   ^}

^
../verifiable/verifiable.cu:807../verifiable/verifiable.cu::22885:: 18note: :expanded from macro 'CASE_TY' 
note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;                     ^

                     ^
../verifiable/verifiable.cu:915../verifiable/verifiable.cu::17841:: 18note: :in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here 
note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7:   case ncclProd: CASE_OP(ReduceProd())note: 
expanded from macro 'CASE_OP'                 ^

../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
../verifiable/verifiable.cu    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
:              ^594
:1: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
812:20: }note: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here^

../verifiable/verifiable.cu:770:  case ncclUint32: CASE_TY(uint32_t)3
:                   ^ 
note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin, true>' requested here
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
  case ncclInt8: CASE_TY(int8_t)
../verifiable/verifiable.cu                 ^:
841:18:../verifiable/verifiable.cu :note: 883in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here:
22: note: expanded from macro 'CASE_TY'
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^911
:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
../verifiable/verifiable.cu:  case ncclMin: CASE_OP(ReduceMin())577
:                ^1
: ../verifiable/verifiable.cuwarning: :void function is missing a return statement [-Wreturn-type]911
:7: note: }expanded from macro 'CASE_OP'

^
../verifiable/verifiable.cu:760      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \:
3      ^:
 note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
../verifiable/verifiable.cu    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
:              ^875
:1: warning: ../verifiable/verifiable.cuvoid function is missing a return statement [-Wreturn-type]:
810:19:} 
note: ^in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here

../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
  case ncclFloat32: CASE_TY(float)../verifiable/verifiable.cu
:                    ^807
:22: ../verifiable/verifiable.cunote: :expanded from macro 'CASE_TY'883
:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;:
                      ^note: 
in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
../verifiable/verifiable.cu:  case ncclMin: CASE_OP(ReduceMin())843
:                ^17
: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here911
:7: note: expanded from macro 'CASE_OP'
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \835
:      ^7
: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)../verifiable/verifiable.cu
:                  ^594
:../verifiable/verifiable.cu1::807 :warning: 22void function is missing a return statement [-Wreturn-type]:
 note: expanded from macro 'CASE_TY'}

^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note:   #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin>' requested here

                     ^
../verifiable/verifiable.cu:843:17:    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i); 
note:               ^in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here

../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)  case ncclAvg: CASE_OP(ReduceAvg{rank_n})

                    ^
                ^../verifiable/verifiable.cu
:883:22: ../verifiable/verifiable.cunote: :expanded from macro 'CASE_TY'835
:7: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \915
:      ^17
: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu799::8831::22 :warning:  note: void function is missing a return statement [-Wreturn-type]expanded from macro 'CASE_TY'

}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807  case ncclMin: CASE_OP(ReduceMin()):
22                ^:
 note: ../verifiable/verifiable.cuexpanded from macro 'CASE_TY':
911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu}:
799^:
1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu:}886
:^19
: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
../verifiable/verifiable.cu:814:  case ncclUint8: CASE_TY(uint8_t)20
:                  ^ 
note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \843
:      ^17
: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu594::5771::1 :warning:  void function is missing a return statement [-Wreturn-type]warning: 
void function is missing a return statement [-Wreturn-type]
}
^
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax, true>' requested here../verifiable/verifiable.cu
:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg, void>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);../verifiable/verifiable.cu
:              ^791
:15../verifiable/verifiable.cu:: 886note: :in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here19
: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22:     elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);note: 
expanded from macro 'CASE_TY'              ^

../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu  case ncclUint64: CASE_TY(uint64_t):
916                   ^:
17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
../verifiable/verifiable.cu:807:22:   case ncclMax: CASE_OP(ReduceMax())note: 
expanded from macro 'CASE_TY'                ^

../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;../verifiable/verifiable.cu
:                     ^594
:1: warning: void function is missing a return statement [-Wreturn-type]../verifiable/verifiable.cu
:843:17}:
 ^note: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax, true>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
  genOutput(ans, op, rank_n, seed, index,../verifiable/verifiable.cu
:  ^835
:7: ../verifiable/verifiable.cunote: :expanded from macro 'CASE_OP'868
:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19:      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \ 
note:       ^in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here

  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:../verifiable/verifiable.cu1::875 :warning: 1void function is missing a return statement [-Wreturn-type]:
 warning: void function is missing a return statement [-Wreturn-type]
}
}^

^
../verifiable/verifiable.cu../verifiable/verifiable.cu::889760::193::  note: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested herein instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here

  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'  genInput(ans, op, rank_n, rank_me, seed, index,

  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceAvg>' requested here
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17:    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i); 
note:               ^in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here

../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here  case ncclMax: CASE_OP(ReduceMax())

                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22:      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \ 
note:       ^expanded from macro 'CASE_TY'

  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \../verifiable/verifiable.cu
      ^:
706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())../verifiable/verifiable.cu
                ^:
675../verifiable/verifiable.cu::1911:: 7warning: :void function is missing a return statement [-Wreturn-type] 
note: expanded from macro 'CASE_OP'}

^
../verifiable/verifiable.cu:760:3:      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \ 
note:       ^in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char>' requested here

  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916../verifiable/verifiable.cu::17675: note: :in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here1
: warning: void function is missing a return statement [-Wreturn-type]
  case ncclMax: CASE_OP(ReduceMax())
                ^}

../verifiable/verifiable.cu^:
911:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int>' requested here
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::875799::11::  warning: warning: void function is missing a return statement [-Wreturn-type]void function is missing a return statement [-Wreturn-type]

}
}^

^
../verifiable/verifiable.cu:../verifiable/verifiable.cu886::81519::21 :note:  in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested herenote: 
in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883  case ncclFloat16: CASE_TY(__half):
22                    ^:
 note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;

                     ^../verifiable/verifiable.cu
:911:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())../verifiable/verifiable.cu
:           ^594
:../verifiable/verifiable.cu1::835 :warning: 7void function is missing a return statement [-Wreturn-type]:
 note: expanded from macro 'CASE_OP'
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^868
:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^}

^
../verifiable/verifiable.cu../verifiable/verifiable.cu::846890::1220::  note: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested herein instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here

  case ncclUint64: CASE_TY(uint64_t)  default: CASE_OP(ReducePreMulSum())

                   ^           ^

../verifiable/verifiable.cu../verifiable/verifiable.cu::883835::227::  note: note: expanded from macro 'CASE_TY'expanded from macro 'CASE_OP'

  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
../verifiable/verifiable.cu      ^:
917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::817594::221::  note: warning: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested herevoid function is missing a return statement [-Wreturn-type]

}
^
../verifiable/verifiable.cu:770  case ncclBfloat16: CASE_TY(hip_bfloat16):
3                     ^:
 note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd, true>' requested here
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;

                     ^
  case ncclUint64: CASE_TY(uint64_t)../verifiable/verifiable.cu
:                   ^846
:12../verifiable/verifiable.cu:: 883note: :in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here22
: note: expanded from macro 'CASE_TY'
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7:   #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;note: 
expanded from macro 'CASE_OP'                     ^

../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
../verifiable/verifiable.cu           ^:
875:1:../verifiable/verifiable.cu :warning: 835void function is missing a return statement [-Wreturn-type]:
7: note: }expanded from macro 'CASE_OP'

^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \  case ncclFloat64: CASE_TY(double)

      ^                    ^

../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}../verifiable/verifiable.cu
^:
594:1: warning: void function is missing a return statement [-Wreturn-type]../verifiable/verifiable.cu
:770:3: note: }in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg, true>' requested here

^
  genOutput(ans, op, rank_n, seed, index,
../verifiable/verifiable.cu  ^:
770:3:../verifiable/verifiable.cu :note: 868in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil, true>' requested here:
15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);  genOutput(ans, op, rank_n, seed, index,

  ^              ^

../verifiable/verifiable.cu../verifiable/verifiable.cu::886868::1915::  note: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested herein instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil>' requested here

  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;

                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:  case ncclAvg: CASE_OP(ReduceAvg{rank_n})22
:                ^ 
note: ../verifiable/verifiable.cuexpanded from macro 'CASE_TY':
911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu883:22::594 :note: 1expanded from macro 'CASE_TY'
: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;770
:                     ^3
: note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil, true>' requested here:
919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  genOutput(ans, op, rank_n, seed, index,  case ncclAvg: CASE_OP(ReduceAvg{rank_n})

  ^                ^

../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'../verifiable/verifiable.cu
:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())../verifiable/verifiable.cu
:                ^875
:1: ../verifiable/verifiable.cuwarning: :void function is missing a return statement [-Wreturn-type]909
:7:} 
note: ^expanded from macro 'CASE_OP'

../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^883
:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here../verifiable/verifiable.cu
:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
  case ncclSum: CASE_OP(ReduceSum())^

                ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu909::8907::20 :note:  expanded from macro 'CASE_OP'note: 
in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;:
770                     ^:
3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum, true>' requested here
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868  case ncclSum: CASE_OP(ReduceSum()):
15                ^:
 ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here909
:7: note: expanded from macro 'CASE_OP'
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
  case ncclUint8: CASE_TY(uint8_t)      ^

                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}  case ncclFloat64: CASE_TY(double)

^                    ^

../verifiable/verifiable.cu../verifiable/verifiable.cu::883770::223::  note: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum, true>' requested hereexpanded from macro 'CASE_TY'

  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum>' requested here
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);

                     ^              ^

../verifiable/verifiable.cu:887:19:../verifiable/verifiable.cu :note: 914in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here:
17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^911
:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::594594::11::  warning: warning: void function is missing a return statement [-Wreturn-type]void function is missing a return statement [-Wreturn-type]

}}

^^

../verifiable/verifiable.cu:770:3: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum, true>' requested here770
:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15:   genOutput(ans, op, rank_n, seed, index,note: 
in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here  ^

../verifiable/verifiable.cu:868:15:     elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);note: 
in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum>' requested here              ^

../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);

                   ^              ^

../verifiable/verifiable.cu:883:../verifiable/verifiable.cu22::885 :note: 18expanded from macro 'CASE_TY':
 note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu883::92222::12 : note: note: expanded from macro 'CASE_TY'in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here

  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \

      ^                     ^

../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::875883::122::  warning: note: void function is missing a return statement [-Wreturn-type]expanded from macro 'CASE_TY'

}
^
../verifiable/verifiable.cu:887:19:  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break; 
note:                      ^in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here

../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
  default: CASE_OP(ReducePreMulSum())                  ^

           ^
../verifiable/verifiable.cu:911../verifiable/verifiable.cu::7883:: 22note: :expanded from macro 'CASE_OP' 
note: expanded from macro 'CASE_TY'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu693::9141::17 :warning:  void function is missing a return statement [-Wreturn-type]note: 
in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu  genOutput(ans, op, rank_n, seed, index,:
911  ^:
7: note: ../verifiable/verifiable.cu:expanded from macro 'CASE_OP'868
:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \:
895      ^:
21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu911::6937::1 :note:  expanded from macro 'CASE_OP'warning: 
void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;:
1049                     ^:
1: warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu}:
914^:
17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclSum: CASE_OP(ReduceSum())  case ncclMax: CASE_OP(ReduceMax())

                ^                ^

../verifiable/verifiable.cu../verifiable/verifiable.cu::9111061::75::  note: note: expanded from macro 'CASE_OP'expanded from macro 'CASE_OP'

    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \../verifiable/verifiable.cu
:      ^
1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]../verifiable/verifiable.cu
:641}:
1^:
 warning: void function is missing a return statement [-Wreturn-type]
../verifiable/verifiable.cu:1065:17: }note: 
in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceSum>' requested here^

  case ncclSum: CASE_OP(ReduceSum())../verifiable/verifiable.cu
:                ^770
:3: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here1061
:5: note: expanded from macro 'CASE_OP'
  genOutput(ans, op, rank_n, seed, index,
  ^    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \

    ^
../verifiable/verifiable.cu:../verifiable/verifiable.cu868::110815::19 :note:  in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceSum>' requested herenote: 
in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9:    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i); 
note:               ^expanded from macro 'CASE_TY'

../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \

        ^                    ^

../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \

}      ^

^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]../verifiable/verifiable.cu
:1049:1:} 
warning: ^void function is missing a return statement [-Wreturn-type]

}
^
../verifiable/verifiable.cu:../verifiable/verifiable.cu895::107021::17 :note:  in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested herenote: 
in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})  case ncclFloat32: CASE_TY(float)

                ^                    ^

../verifiable/verifiable.cu:1061:5: note: ../verifiable/verifiable.cuexpanded from macro 'CASE_OP':
883:22: note: expanded from macro 'CASE_TY'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;

                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^  case ncclSum: CASE_OP(ReduceSum())

                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)../verifiable/verifiable.cu
:                    ^1049
:1../verifiable/verifiable.cu:: 883warning: :void function is missing a return statement [-Wreturn-type]22
: }note: 
^expanded from macro 'CASE_TY'

../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \:
914    ^:
17: note: ../verifiable/verifiable.cuin instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here:
1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^  case ncclUint8: CASE_TY(uint8_t, uint8_t)

                  ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::1103911::97::  note: note: expanded from macro 'CASE_TY'expanded from macro 'CASE_OP'

      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \

        ^      ^

../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::1049875::11::  warning: warning: void function is missing a return statement [-Wreturn-type]void function is missing a return statement [-Wreturn-type]

}
^}

^
../verifiable/verifiable.cu:1073:12: ../verifiable/verifiable.cunote: :in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here886
:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:  case ncclUint8: CASE_TY(uint8_t)5
:                  ^ 
note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9:   #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;note: 
expanded from macro 'CASE_TY'                     ^

../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \  case ncclMin: CASE_OP(ReduceMin())

        ^                ^

../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::1049875::11::  warning: warning: void function is missing a return statement [-Wreturn-type]void function is missing a return statement [-Wreturn-type]

}}

^^

../verifiable/verifiable.cu:1065:17../verifiable/verifiable.cu:: 887note: :in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceNil>' requested here19
: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'  case ncclInt32: CASE_TY(int32_t)

                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \

    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;

                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu../verifiable/verifiable.cu::5941066::117::  warning: note: void function is missing a return statement [-Wreturn-type]in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMin>' requested here

}
^
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu../verifiable/verifiable.cu::7701061::35::  note: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin, true>' requested hereexpanded from macro 'CASE_OP'

    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
  genOutput(ans, op, rank_n, seed, index,    ^

  ^
../verifiable/verifiable.cu:1110:20../verifiable/verifiable.cu:: 868note: :in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here15
: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \  case ncclInt32: CASE_TY(int32_t)

        ^                  ^

../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \1111
:      ^19
: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
../verifiable/verifiable.cu^
:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}../verifiable/verifiable.cu
:^770
:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin, false>' requested here../verifiable/verifiable.cu
:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  genOutput(ans, op, rank_n, seed, index,  case ncclSum: CASE_OP(ReduceSum())

  ^                ^

../verifiable/verifiable.cu:../verifiable/verifiable.cu1061::8685::15 :note:  expanded from macro 'CASE_OP'note: 
in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin>' requested here
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);:
1113              ^:
21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here../verifiable/verifiable.cu
:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'  case ncclFloat16: CASE_TY(__half)

                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
../verifiable/verifiable.cu        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
:        ^594
:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce.cu:64:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoall.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:70:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoall.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoall.cu:70:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:27:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:85:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:89:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:170:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx936.
3 warnings generated when compiling for gfx936.
3 warnings generated when compiling for gfx936.
scatter.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:80:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx936.
sendrecv.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
sendrecv.cu:50:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx936.
sendrecv.cu:78:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx936.
3 warnings generated when compiling for gfx936.
common.cu:106:49: warning: 'sscanf' may overflow; destination buffer in argument 4 has size 1, but the corresponding specifier may require size 2 [-Wfortify-source]
    int count = sscanf(value, "%lf %1s", &size, &size_lit);
                                                ^
all_reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:210:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_reduce.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_reduce.cu:65:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:410:14: warning: enumeration value 'ncclNumTypes' not handled in switch [-Wswitch]
      switch(type) {
             ^~~~
broadcast.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
broadcast.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:629:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
broadcast.cu:74:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx936.
3 warnings generated when compiling for gfx936.
common.cu:269:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:524:3: note: in instantiation of function template specialization 'Allreduce<double>' requested here
  Allreduce(args, &deltaSec, average);
  ^
common.cu:269:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:593:7: note: in instantiation of function template specialization 'Allreduce<long long>' requested here
      Allreduce(args, &wrongElts1, /*sum*/4);
      ^
6 warnings generated when compiling for gfx936.
reduce_scatter.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:51:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:69:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for gfx936.
reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce.cu:64:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_gather.cu:70:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
gather.cu:85:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:27:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoall.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:89:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoall.cu:52:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoall.cu:70:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
alltoallv.cu:170:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
sendrecv.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
sendrecv.cu:50:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
sendrecv.cu:78:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
scatter.cu:80:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for host.
3 warnings generated when compiling for host.
all_reduce.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
all_reduce.cu:47:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for host.
all_reduce.cu:65:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for host.
broadcast.cu:17:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
broadcast.cu:46:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for host.
broadcast.cu:74:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for host.
common.cu:106:49: warning: 'sscanf' may overflow; destination buffer in argument 4 has size 1, but the corresponding specifier may require size 2 [-Wfortify-source]
    int count = sscanf(value, "%lf %1s", &size, &size_lit);
                                                ^
common.cu:210:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for host.
common.cu:410:14: warning: enumeration value 'ncclNumTypes' not handled in switch [-Wswitch]
      switch(type) {
             ^~~~
common.cu:629:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for host.
3 warnings generated when compiling for host.
common.cu:269:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:524:3: note: in instantiation of function template specialization 'Allreduce<double>' requested here
  Allreduce(args, &deltaSec, average);
  ^
common.cu:269:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
common.cu:593:7: note: in instantiation of function template specialization 'Allreduce<long long>' requested here
      Allreduce(args, &wrongElts1, /*sum*/4);
      ^
reduce_scatter.cu:20:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:51:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
reduce_scatter.cu:69:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
3 warnings generated when compiling for host.
6 warnings generated when compiling for host.
368 warnings generated when compiling for gfx906.
368 warnings generated when compiling for gfx928.
368 warnings generated when compiling for gfx926.
../verifiable/verifiable.cu:850:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:926:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:427:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:453:3: note: in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned int>' requested here
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
  ^
../verifiable/verifiable.cu:632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<__half>' requested here
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);
        ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:427:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:453:3: note: in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned long>' requested here
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
  ^
../verifiable/verifiable.cu:632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<double>' requested here
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);
        ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
368 warnings generated when compiling for gfx936.
../verifiable/verifiable.cu:850:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:926:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, true>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:612:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, false>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:833:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, ReduceNil(), rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:427:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:453:3: note: in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned int>' requested here
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
  ^
../verifiable/verifiable.cu:632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<__half>' requested here
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);
        ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:633:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:427:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:453:3: note: in instantiation of function template specialization '(anonymous namespace)::genSumXY<unsigned long>' requested here
  genSumXY(subrank_n, subrank_me, rng, max_mant, x0_mant, y0_mant);
  ^
../verifiable/verifiable.cu:632:9: note: in instantiation of function template specialization '(anonymous namespace)::genInOutFloatSum<double>' requested here
  ans = genInOutFloatSum<T>(/*input_not_output=*/true, rank_n, rank_me, seed, index, /*same_sign=*/false);
        ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:838:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:730:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:746:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:729:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput<T>(ans, ReduceMax(), rank_n, rank_me, seed, index, integral);
  ^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:839:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:840:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:654:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:841:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:577:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg, void>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:706:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:843:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:809:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:810:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:811:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:812:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:813:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:675:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:814:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:815:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:817:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<float, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:819:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:799:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:685:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:760:3: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double>' requested here
  genInput(ans, op, rank_n, rank_me, seed, index,
  ^
../verifiable/verifiable.cu:791:15: note: in instantiation of function template specialization '(anonymous namespace)::genInput<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genInput<T>(op, rank_n, rank_me, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:820:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:807:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareInput2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, rank_me, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:846:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareInput1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:835:7: note: expanded from macro 'CASE_OP'
      prepareInput1(elts, elt_n, elt_ty, op, rank_n, rank_me, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceNil>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceNil>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceNil>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceNil>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:909:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, ReduceNil(), rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:641:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:914:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMin>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMin>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMin>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMin>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:915:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceMax>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceMax>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax, false>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceMax>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceMax>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:916:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceProd>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceProd>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:662:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceProd>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceProd>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:917:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReduceAvg>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:717:2: warning: void function is missing a return statement [-Wreturn-type]
 }
 ^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReduceAvg>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReduceAvg>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:919:17: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:885:18: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<signed char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt8: CASE_TY(int8_t)
                 ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:886:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint8: CASE_TY(uint8_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:887:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt32: CASE_TY(int32_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:888:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint32: CASE_TY(uint32_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:889:19: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclInt64: CASE_TY(int64_t)
                  ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:594:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum, true>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:890:20: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclUint64: CASE_TY(uint64_t)
                   ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<__half, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:891:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<__half, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat16: CASE_TY(__half)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:893:22: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<hip_bfloat16, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16)
                     ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<float, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:895:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<float, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat32: CASE_TY(float)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:875:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:693:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:770:3: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double>' requested here
  genOutput(ans, op, rank_n, seed, index,
  ^
../verifiable/verifiable.cu:868:15: note: in instantiation of function template specialization '(anonymous namespace)::genOutput<double, (anonymous namespace)::ReducePreMulSum>' requested here
    elts[i] = genOutput<T>(op, rank_n, seed, elt_ix0+i);
              ^
../verifiable/verifiable.cu:896:21: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected2<double, (anonymous namespace)::ReducePreMulSum>' requested here
  case ncclFloat64: CASE_TY(double)
                    ^
../verifiable/verifiable.cu:883:22: note: expanded from macro 'CASE_TY'
  #define CASE_TY(T) prepareExpected2<<<block_n, 512, 0, stream>>>((T*)elts, elt_n, op, rank_n, seed, elt_ix0); break;
                     ^
../verifiable/verifiable.cu:922:12: note: in instantiation of function template specialization '(anonymous namespace)::prepareExpected1<(anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:911:7: note: expanded from macro 'CASE_OP'
      prepareExpected1(elts, elt_n, elt_ty, op, rank_n, seed, elt_ix0, stream); \
      ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<signed char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1107:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<signed char, unsigned char>' requested here
  case ncclInt8: CASE_TY(int8_t, uint8_t)
                 ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned char, unsigned char, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1108:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned char, unsigned char>' requested here
  case ncclUint8: CASE_TY(uint8_t, uint8_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1109:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<int, unsigned int>' requested here
  case ncclInt32: CASE_TY(int32_t, uint32_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned int, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1110:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned int, unsigned int>' requested here
  case ncclUint32: CASE_TY(uint32_t, uint32_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1111:19: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<long, unsigned long>' requested here
  case ncclInt64: CASE_TY(int64_t, uint64_t)
                  ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<unsigned long, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1112:20: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<unsigned long, unsigned long>' requested here
  case ncclUint64: CASE_TY(uint64_t, uint64_t)
                   ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1015:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyPrepared<unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1101:9: note: expanded from macro 'CASE_TY'
        verifyPrepared<<<block_n, 512, 0, stream>>>((Uint const*)results, (Uint const*)expected, elt_n, tolerance, bad_elt_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<__half, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1113:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<__half, unsigned short>' requested here
  case ncclFloat16: CASE_TY(__half, uint16_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<hip_bfloat16, unsigned short, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1115:22: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<hip_bfloat16, unsigned short>' requested here
  case ncclBfloat16: CASE_TY(hip_bfloat16, uint16_t)
                     ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<float, unsigned int, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1117:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<float, unsigned int>' requested here
  case ncclFloat32: CASE_TY(float, uint32_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1077:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceNil>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1058:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1065:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceSum>' requested here
  case ncclSum: CASE_OP(ReduceSum())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1066:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMin>' requested here
  case ncclMin: CASE_OP(ReduceMin())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1067:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceMax>' requested here
  case ncclMax: CASE_OP(ReduceMax())
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1068:18: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceProd>' requested here
  case ncclProd: CASE_OP(ReduceProd())
                 ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1070:17: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReduceAvg>' requested here
  case ncclAvg: CASE_OP(ReduceAvg{rank_n})
                ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
../verifiable/verifiable.cu:1049:1: warning: void function is missing a return statement [-Wreturn-type]
}
^
../verifiable/verifiable.cu:1073:12: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline2<double, unsigned long, (anonymous namespace)::ReducePreMulSum>' requested here
  default: CASE_OP(ReducePreMulSum())
           ^
../verifiable/verifiable.cu:1061:5: note: expanded from macro 'CASE_OP'
    verifyInline2<T, Uint><<<block_n, 512, 0, stream>>> \
    ^
../verifiable/verifiable.cu:1118:21: note: in instantiation of function template specialization '(anonymous namespace)::verifyInline1<double, unsigned long>' requested here
  case ncclFloat64: CASE_TY(double, uint64_t)
                    ^
../verifiable/verifiable.cu:1103:9: note: expanded from macro 'CASE_TY'
        verifyInline1<T, Uint>((T const*)results, elt_n, red_op, rank_n, seed, elt_ix0, tolerance, bad_elt_n, stream, block_n); \
        ^
368 warnings generated when compiling for host.
Linking  /data1/sunzhq/rccl-tests-develop/build/all_reduce.o > /data1/sunzhq/rccl-tests-develop/build/all_reduce_perf
Linking  /data1/sunzhq/rccl-tests-develop/build/all_gather.o > /data1/sunzhq/rccl-tests-develop/build/all_gather_perf
Linking  /data1/sunzhq/rccl-tests-develop/build/broadcast.o > /data1/sunzhq/rccl-tests-develop/build/broadcast_perf
Linking  /data1/sunzhq/rccl-tests-develop/build/reduce_scatter.o > /data1/sunzhq/rccl-tests-develop/build/reduce_scatter_perf
Linking  /data1/sunzhq/rccl-tests-develop/build/reduce.o > /data1/sunzhq/rccl-tests-develop/build/reduce_perf
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/all_reduce_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/all_reduce.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/all_gather_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/all_gather.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/broadcast_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/broadcast.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/reduce_scatter_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/reduce_scatter.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/reduce_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/reduce.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
Linking  /data1/sunzhq/rccl-tests-develop/build/alltoall.o > /data1/sunzhq/rccl-tests-develop/build/alltoall_perf
Linking  /data1/sunzhq/rccl-tests-develop/build/scatter.o > /data1/sunzhq/rccl-tests-develop/build/scatter_perf
Linking  /data1/sunzhq/rccl-tests-develop/build/gather.o > /data1/sunzhq/rccl-tests-develop/build/gather_perf
Linking  /data1/sunzhq/rccl-tests-develop/build/sendrecv.o > /data1/sunzhq/rccl-tests-develop/build/sendrecv_perf
Linking  /data1/sunzhq/rccl-tests-develop/build/alltoallv.o > /data1/sunzhq/rccl-tests-develop/build/alltoallv_perf
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/alltoall_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/alltoall.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/scatter_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/scatter.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/gather_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/gather.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/sendrecv_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/sendrecv.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
/opt/dtk/bin/hipcc -o /data1/sunzhq/rccl-tests-develop/build/alltoallv_perf -std=c++14 -I/opt/dtk/rccl// -I/opt/dtk/rccl//include -I/opt/dtk/include -I/opt/dtk/include/hip -O3 -DMPI_SUPPORT -I/opt/mpi/include -I/opt/mpi/include/mpi /data1/sunzhq/rccl-tests-develop/build/alltoallv.o /data1/sunzhq/rccl-tests-develop/build/common.o /data1/sunzhq/rccl-tests-develop/build/timer.o /data1/sunzhq/rccl-tests-develop/build/verifiable/verifiable.o -Wl,-rpath,/opt/dtk/rccl/ -L/opt/dtk/rccl/ -L/opt/dtk/rccl//lib /opt/dtk/rccl/lib/librccl.so -L/opt/dtk/lib -lhsa-runtime64 -lrt -pthread -L/opt/mpi/lib -lmpi -lrccl
make[1]: Leaving directory '/data1/sunzhq/rccl-tests-develop/src'