}
									}
									reconstructAbleConfig = valid >= m.data-hasParity && valid < m.data
									startOffset = offset
									offset++
									continue
								}
								for shardIdx, ok := range shardConfig {
									if ok != 0 {
										shards[shardIdx] = append(shards[shardIdx], splitData[shardIdx][offset])
									}

LogicalResult UnrollSplit::matchAndRewrite(TFL::SplitOp split_op,
                                           PatternRewriter& rewriter) const {
  auto num_splits = split_op.getNumSplits();
  auto input = split_op.getValue();
  auto input_type = mlir::dyn_cast<RankedTensorType>(input.getType());
  if (input_type == nullptr || !input_type.hasStaticShape()) return failure();

  for (auto result : split_op.getResults()) {

  }

  // Creates a split op that splits |src_input| along |split_dimension|.
  llvm::SmallVector<mlir::Type, 4> output_types(num_split, output_type);
  *split_op = builder->create<mlir::TF::SplitOp>(
      location, output_types, split_dimension_op.getOutput(), src_input);
  (*split_op)->setAttr(
      kNumSplitAttr,
      builder->getIntegerAttr(builder->getIntegerType(32), num_split));
  return mlir::success();
}

}

func header() http.Header {
	header := http.Header{}
	header.Set("Content-Type", runtime.ContentTypeJSON)
	return header
}

// splitPath returns the segments for a URL path.
func splitPath(path string) []string {
	path = strings.Trim(path, "/")
	if path == "" {
		return []string{}
	}
	return strings.Split(path, "/")
}

func RequestInfoFrom(ctx context.Context) (*RequestInfo, bool) {
	info, ok := ctx.Value(requestInfoKey).(*RequestInfo)
	return info, ok
}

// splitPath returns the segments for a URL path.
func splitPath(path string) []string {
	path = strings.Trim(path, "/")
	if path == "" {
		return []string{}
	}
	return strings.Split(path, "/")

        BY_PATH = new Cache(ROOT);
    }

    private final String path;
    private final String[] components;
    private final ModelPath parent;

    public ModelPath(String path) {
        this(path, splitPath(path));
    }

    private ModelPath(String path, String[] components) {
        // one should really avoid using this constructor as it is totally inefficient

    auto split_op = rewriter.create<TF::SplitOp>(loc, output_types,
                                                 split_dimension_op.getOutput(),
                                                 reshape_op.getOutput());

    // Squeeze each batch, i.e. reshape
    // [1, num_rows, num_cols] -> [num_rows, num_cols]
    for (const auto& split_value : split_op.getOutput()) {

  %2:3 = "tfl.split_v"(%arg0, %0, %1) {num_splits = 3 : i32} : (tensor<?x13x13x85xf32>, tensor<3xi32>, tensor<i32>) -> (tensor<*xf32>, tensor<*xf32>, tensor<*xf32>)
  func.return %2#0, %2#1, %2#2 : tensor<*xf32>, tensor<*xf32>, tensor<*xf32>
}

// CHECK-LABEL: @unrollSplitVUnknownRankResults
// CHECK-NOT: "tfl.slice"
// CHECK: "tfl.split_v"

// -----

	// Extract the host from the headers and then remove it.
	c.hostHeader = c.headers.Get(hostHeader)
	c.headers.Del(hostHeader)

	c.urlHost, c.urlPath = splitPath(c.Request.Url)

	c.method = c.Request.Method
	if c.method == "" {
		c.method = "GET"
	}

	if i := strings.IndexByte(c.Request.Url, ':'); i > 0 {
		c.scheme = scheme.Instance(strings.ToLower(c.Request.Url[0:i]))

	policyDBUsersListKey    = "policydb/users/"
	policyDBSTSUsersListKey = "policydb/sts-users/"
	policyDBGroupsListKey   = "policydb/groups/"
)

// splitPath splits a path into a top-level directory and a child item. The
// parent directory retains the trailing slash.
func splitPath(s string, lastIndex bool) (string, string) {
	var i int
	if lastIndex {
		i = strings.LastIndex(s, "/")
	} else {
		i = strings.Index(s, "/")
	}