get() {
      val pathStart = url.indexOf('/', scheme.length + 3)
      val pathEnd = url.delimiterOffset("?#", pathStart, url.length)
      val result = mutableListOf<String>()
      var i = pathStart
      while (i < pathEnd) {
        i++ // Skip the '/'.
        val segmentEnd = url.delimiterOffset('/', i, pathEnd)
        result.add(url.substring(i, segmentEnd))
        i = segmentEnd
      }

		}
	} else if err := module.CheckImportPath(modPath); err != nil {
		if pathErr, ok := err.(*module.InvalidPathError); ok {
			pathErr.Kind = "module"
			// Same as build.IsLocalPath()
			if pathErr.Path == "." || pathErr.Path == ".." ||
				strings.HasPrefix(pathErr.Path, "./") || strings.HasPrefix(pathErr.Path, "../") {
				pathErr.Err = errors.New("is a local import path")
			}
		}
		base.Fatal(err)

				if err != nil {
					return true, nil, err
				}
				patched, err := legacyscheme.Scheme.ConvertToVersion(obj, apps.SchemeGroupVersion)
				if err != nil {
					return true, nil, err
				}
				return true, patched, err
			default:
				return false, nil, nil
			}

		})

					} else {
						var resultErrno, expectErrno uintptr
						if pathErr, ok := err.(*os.PathError); ok {
							if errno, pok := pathErr.Err.(syscall.Errno); pok {
								resultErrno = uintptr(errno)
							}
						}
						if pathErr, ok := testCase.expectedErr.(*os.PathError); ok {
							if errno, pok := pathErr.Err.(syscall.Errno); pok {
								expectErrno = uintptr(errno)
							}
						}

	}
	pastEnd := false
	if len(st.str) > 0 && st.str[0] == 'p' {
		st.advance(1)
		pastEnd = true
	}
	if len(st.str) == 0 || st.str[0] != 'E' {
		st.fail("expected E after subobject")
	}
	st.advance(1)
	return &Subobject{
		Type:      typ,
		SubExpr:   expr,
		Offset:    offset,
		Selectors: selectors,
		PastEnd:   pastEnd,
	}
}

    TF_Int64Tensor:$iter_id
  );
}

def TF_ResourceGatherNdOp : TF_Op<"ResourceGatherNd", []> {
  let summary = "GatherNd on a resource.";

  let description = [{
This op reads the variable referenced by the first argument, and
then performs a GatherNd operation on it.
  }];

  let arguments = (ins
    Arg<TF_ResourceTensor, "", [TF_VariableRead]>:$resource,

func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil {
		return
	}
	var _p1 *byte
	_p1, err = BytePtrFromString(link)
	if err != nil {
		return
	}

func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil {
		return
	}
	var _p1 *byte
	_p1, err = BytePtrFromString(link)
	if err != nil {
		return
	}

build:win_clang_xla --compiler=clang-cl
build:win_clang_xla --linkopt=/FORCE:MULTIPLE
build:win_clang_xla --host_linkopt=/FORCE:MULTIPLE
test:win_clang_xla --action_env=PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PY;.PYW
test:win_clang_xla --linkopt=/FORCE:MULTIPLE
test:win_clang_xla --host_linkopt=/FORCE:MULTIPLE

# Options to build TensorFlow 1.x or 2.x.

  %0 = "tf.TensorScatterAdd"(%arg0, %arg1, %arg2) : (tensor<7xi64>, tensor<1x1xi32>, tensor<1xi64>) -> tensor<7xi64>
  func.return %0 : tensor<7xi64>

  // CHECK-LABEL: scatter_nd_add
  // CHECK:  %[[GATHER:.*]] = "tf.GatherNd"(%arg0, %arg1) <{bad_indices_policy = ""}> : (tensor<7xi64>, tensor<1x1xi32>) -> tensor<1xi64>
  // CHECK:  %[[ADD:.*]] = "tf.Add"(%arg2, %[[GATHER]]) : (tensor<1xi64>, tensor<1xi64>) -> tensor<1xi64>