const FunctionBody* fbody = nullptr;
      std::vector<int> constant_arg_indices;
      std::vector<int> resource_arg_indices;

      NameAttrList function;
      TF_RETURN_IF_ERROR(NameAndAttrsFromFunctionCall(node->def(), &function));

      // Force all constants to be on the host memory.
      TF_RETURN_IF_ERROR(GetBodyAndConstantsAndResources(
          flr, function, &fbody, &constant_arg_indices, &resource_arg_indices));

	if userns {
		cmd.SysProcAttr.Cloneflags = syscall.CLONE_NEWUSER
		const nobody = 65534
		uid := os.Getuid()
		gid := os.Getgid()
		cmd.SysProcAttr.UidMappings = []syscall.SysProcIDMap{{
			ContainerID: int(nobody),
			HostID:      uid,
			Size:        int(1),
		}}
		cmd.SysProcAttr.GidMappings = []syscall.SysProcIDMap{{
			ContainerID: int(nobody),
			HostID:      gid,
			Size:        int(1),
		}}

|
| [1.0, 2.0[
| 1.5
|
| Any version between `1.0` and `2.0`, `1.5` if nobody else cares. An upgrade to `2.4` is accepted. +
🔒

| Tested with `1.5`, but follows semantic versioning.
| [1.0, 2.0[
|
| 1.5
|
| Any version between `1.0` and `2.0` (exclusive), `1.5` if nobody else cares. +
Overwrites versions from transitive dependencies. +
🔒

| Same as above, with `1.4` known broken.

BuildXlaCompilerArgumentFromTensorSpec(
    const FunctionBody* fbody, absl::Span<int const> must_be_constant_idxs,
    absl::Span<const Tensor* const> inputs,
    absl::Span<VariableInfo const> variable_args,
    absl::Span<const ArgShapeAndDType> flat_arg_shape_and_dtype) {
  TF_RET_CHECK(fbody != nullptr);
  auto& input_args = fbody->record->fdef().signature().input_arg();
  int input_arg_size = input_args.size();

      [&](const NameAttrList &function, const FunctionBody **fbody) {
        std::unique_ptr<FunctionBody> new_fbody;
        TF_RETURN_IF_ERROR(FunctionDefToBodyHelper(*fld.Find(function.name()),
                                                   AttrSlice(&function.attr()),
                                                   &fld, &new_fbody));
        *fbody = new_fbody.get();
        fbodies.push_back(std::move(new_fbody));

			StatusCode: http.StatusNotFound,
			Body:       http.NoBody,
			fileErr:    err,
		}, nil
	}

	if os.IsPermission(err) {
		return &Response{
			URL:        u.Redacted(),
			Status:     http.StatusText(http.StatusForbidden),
			StatusCode: http.StatusForbidden,
			Body:       http.NoBody,
			fileErr:    err,
		}, nil
	}

	if err != nil {
		return nil, err
	}

		WelcomeMessage: fmt.Sprintf("Welcome to '%s' FTP Server Version='%s' License='%s'", MinioStoreName, MinioLicense, Version),
		Driver:         NewFTPDriver(),
		Port:           port,
		Perm:           ftp.NewSimplePerm("nobody", "nobody"),
		TLS:            tls,
		KeyFile:        tlsPrivateKey,
		CertFile:       tlsPublicCert,
		ExplicitFTPS:   tls,
		Logger:         &minioLogger{},
		PassivePorts:   portRange,
		PublicIP:       publicIP,

  }

  std::unique_ptr<FunctionBody> fbody;
  TF_RETURN_IF_ERROR(FunctionDefToBodyHelper(*fdef, n->attrs(), fld, &fbody));

  int original_arg_count = fbody->arg_nodes.size();

  TF_ASSIGN_OR_RETURN(auto lifted_arg_nodes_and_outside_compilation_nodes,
                      LiftedArgsAndOutsideCompilationNodesInFunctionBody(
                          *fbody, outside_compilation_attr_to_node));

    public fun renderBody(
        analysisSession: KaSession,
        symbol: KaSymbolWithMembers,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

    public object NO_BODY : KaClassifierBodyRenderer {
        override fun renderBody(
            analysisSession: KaSession,
            symbol: KaSymbolWithMembers,
            declarationRenderer: KaDeclarationRenderer,

				},
				User: &user.DefaultInfo{
					Name:   "nobody",
					Groups: []string{user.AllAuthenticated, "nogroup"},
				},
			}},
		},
		true: {
			false: {{
				RequestInfo: &request.RequestInfo{
					IsResourceRequest: false,
					Path:              "/foo/bar",
					Verb:              "frobulate"},
				User: &user.DefaultInfo{
					Name:   "nobody",