docs: public static INDArrayIndex[] resolveLong(long[] shapeInfo, INDArrayIndex... intendedIndexes) {
          int numSpecified = 0;
          for (int i = 0; i < intendedIndexes.length; i++) {
              if (intendedIndexes[i] instanceof SpecifiedIndex)
                  numSpecified++;
          }
  
          if (numSpecified > 0) {
              val shape = Shape.shapeOf(shapeInfo);
              INDArrayIndex[] ret = new INDArrayIndex[intendedIndexes.length];
              for (int i = 0; i < intendedIndexes.length; i++) {
                  if (intendedIndexes[i] instanceof SpecifiedIndex)
                      ret[i] = intendedIndexes[i];
                  else {
                      if (intendedIndexes[i] instanceof NDArrayIndexAll) {
                          SpecifiedIndex specifiedIndex = new SpecifiedIndex(ArrayUtil.range(0L, shape[i]));
                          ret[i] = specifiedIndex;
                      } else if (intendedIndexes[i] instanceof IntervalIndex) {
                          IntervalIndex intervalIndex = (IntervalIndex) intendedIndexes[i];
                          ret[i] = new SpecifiedIndex(ArrayUtil.range(intervalIndex.begin, intervalIndex.end(),
                                          intervalIndex.stride()));
                      } else if(intendedIndexes[i] instanceof PointIndex){
                          ret[i] = intendedIndexes[i];
                      }
                  }
              }
  
              return ret;
          }
  
  
          /**
           * If it's a vector and index asking
           * for a scalar just return the array
           */
          int rank = Shape.rank(shapeInfo);
          val shape = Shape.shapeOf(shapeInfo);
          if (intendedIndexes.length >= rank || Shape.isVector(shapeInfo) && intendedIndexes.length == 1) {
              if(Shape.rank(shapeInfo) == 1){
                  //1D edge case, with 1 index
                  return intendedIndexes;
              }
  
              if (Shape.isRowVectorShape(shapeInfo) && intendedIndexes.length == 1) {
                  INDArrayIndex[] ret = new INDArrayIndex[2];
                  ret[0] = NDArrayIndex.point(0);
                  long size;
                  if (1 == shape[0] && rank == 2)
                      size = shape[1];
                  else
                      size = shape[0];
                  ret[1] = validate(size, intendedIndexes[0]);
                  return ret;
              }
              List<INDArrayIndex> retList = new ArrayList<>(intendedIndexes.length);
              for (int i = 0; i < intendedIndexes.length; i++) {
                  if (i < rank)
                      retList.add(validate(shape[i], intendedIndexes[i]));
                  else
                      retList.add(intendedIndexes[i]);
              }
              return retList.toArray(new INDArrayIndex[retList.size()]);
          }
  
          List<INDArrayIndex> retList = new ArrayList<>(intendedIndexes.length + 1);
          int numNewAxes = 0;
  
          if (Shape.isMatrix(shape) && intendedIndexes.length == 1) {
              retList.add(validate(shape[0], intendedIndexes[0]));
              retList.add(NDArrayIndex.all());
          } else {
              for (int i = 0; i < intendedIndexes.length; i++) {
                  retList.add(validate(shape[i], intendedIndexes[i]));
                  if (intendedIndexes[i] instanceof NewAxis)
                      numNewAxes++;
              }
          }
  
          int length = rank + numNewAxes;
          //fill the rest with all
          while (retList.size() < length)
              retList.add(NDArrayIndex.all());
  
          return retList.toArray(new INDArrayIndex[retList.size()]);
      }