docs: @Override
      public void shuffle(List<INDArray> arrays, Random rnd, List<int[]> dimensions) {
          if (dimensions == null || dimensions.size() == 0)
              throw new RuntimeException("Dimension can't be null or 0-length");
  
          if (arrays == null || arrays.size() == 0)
              throw new RuntimeException("No input arrays provided");
  
          if (dimensions.size() > 1 && arrays.size() != dimensions.size())
              throw new IllegalStateException("Number of dimensions do not match number of arrays to shuffle");
  
          val zero = arrays.get(0);
          int tadLength = 1;
          if (zero.rank() > 1)
              for (int i = 0; i < dimensions.get(0).length; i++) {
                  tadLength *= zero.shape()[dimensions.get(0)[i]];
              }
  
          long numTads = zero.length() / tadLength;
  
          val map = ArrayUtil.buildInterleavedVector(rnd, (int) numTads);
  
          val dataPointers = new PointerPointer(arrays.size());
          val shapePointers = new PointerPointer(arrays.size());
          val tadPointers = new PointerPointer(arrays.size());
          val offsetPointers = new PointerPointer(arrays.size());
  
          val dummy = new PointerPointer(new Pointer[] {null});
  
          List<Pair<DataBuffer, DataBuffer>> list = new ArrayList<>();
  
          val tadManager = Nd4j.getExecutioner().getTADManager();
  
          val ptrMap = new IntPointer(map);
  
          long[] ptrs = new long[arrays.size()];
  
  
          for (int i = 0; i < arrays.size(); i++) {
              val array = arrays.get(i);
  
              Nd4j.getCompressor().autoDecompress(array);
  
              val dimension = dimensions.size() > 1 ? dimensions.get(i) : dimensions.get(0);
  
              val tadBuffers = tadManager.getTADOnlyShapeInfo(array, dimension);
              list.add(tadBuffers);
  
              val hostTadShapeInfo = tadBuffers.getFirst().addressPointer();
  
              val offsets = tadBuffers.getSecond();
  
              if (array.rank() != 1 && offsets.length() != numTads)
                  throw new ND4JIllegalStateException("Can't symmetrically shuffle arrays with non-equal number of TADs");
  
              if (offsets == null)
                  throw new ND4JIllegalStateException("Offsets for shuffle can't be null");
  
              dataPointers.put(i, array.data().addressPointer());
              shapePointers.put(i, array.shapeInfoDataBuffer().addressPointer());
              offsetPointers.put(i, offsets.addressPointer());
              tadPointers.put(i, tadBuffers.getFirst().addressPointer());
          }
  
  
          nativeOps.shuffle(dummy,
                      dataPointers, shapePointers,
                  null, null,
                      dataPointers, shapePointers,
                  null, null,
                  arrays.size(),
                      ptrMap, tadPointers, offsetPointers);
  
  
          dataPointers.address();
          shapePointers.address();
          tadPointers.address();
          offsetPointers.address();
      }