hdrs = ["posix_filesystem_helper.h"],
    deps = [":copy_file"],
)

# On Linux, we can copy files faster using `sendfile`. But not elsewhere.
# Hence, this private library to select which implementation to use.
cc_library(
    name = "copy_file",
    srcs = select({
        "//tensorflow:linux_x86_64": ["copy_file_linux.cc"],
        "//conditions:default": ["copy_file_portable.cc"],
    }),
    hdrs = ["copy_file.h"],

	q.x.Set(x3)
	q.y.Set(y3)
	q.z.Set(z3)
	return q
}

// Select sets q to p1 if cond == 1, and to p2 if cond == 0.
func (q *{{.P}}Point) Select(p1, p2 *{{.P}}Point, cond int) *{{.P}}Point {
	q.x.Select(p1.x, p2.x, cond)
	q.y.Select(p1.y, p2.y, cond)
	q.z.Select(p1.z, p2.z, cond)
	return q
}

// A {{.p}}Table holds the first 15 multiples of a point at offset -1, so [1]P

			resp, err := con.upstreamDeltas.Recv()
			if err != nil {
				upstreamErr(con, err)
				return
			}
			select {
			case con.deltaResponsesChan <- resp:
			case <-con.stopChan:
			}
		}
	}()

	go p.handleUpstreamDeltaRequest(con)
	go p.handleUpstreamDeltaResponse(con)

	for {
		select {
		case err := <-con.upstreamError:
			return err
		case err := <-con.downstreamError:

                select(CommonBuilds.PROJECT_PATH_TEST, CommonBuilds.BUILD_PATH_COMPILE),
                Collections.singletonList(system),
                nonTransitiveDependencyScopes));
        result.add(internalScopeManager.createResolutionScope(
                RS_TEST_RUNTIME,
                InternalScopeManager.Mode.ELIMINATE,

log4j:log4j:1.2.16 FAILED
   Failures:
      - Could not resolve log4j:log4j:1.2.16.
          - Module 'log4j:log4j' has been rejected:
               Cannot select module with conflict on capability 'log4j:log4j:1.2.16' also provided by [org.slf4j:log4j-over-slf4j:1.7.10(compile)]

log4j:log4j:1.2.16 FAILED
\--- org.apache.zookeeper:zookeeper:3.4.9
     \--- compileClasspath

org.slf4j:log4j-over-slf4j:1.7.10 FAILED
   Failures:

    %6 = mhlo.compare  GE, %arg1, %arg3 : (tensor<i32>, tensor<i32>) -> tensor<i1>
    %7 = mhlo.select %6, %arg1, %arg3 : tensor<i1>, tensor<i32>
    %8 = mhlo.compare  EQ, %arg1, %arg3 : (tensor<i32>, tensor<i32>) -> tensor<i1>
    %9 = mhlo.minimum %arg2, %arg4 : tensor<i32>
    %10 = mhlo.select %6, %arg2, %arg4 : tensor<i1>, tensor<i32>
    %11 = mhlo.select %8, %9, %10 : tensor<i1>, tensor<i32>
    mhlo.return %7, %11 : tensor<i32>, tensor<i32>
  }

var origRlimitNofile atomic.Pointer[Rlimit]

// Some systems set an artificially low soft limit on open file count, for compatibility
// with code that uses select and its hard-coded maximum file descriptor
// (limited by the size of fd_set).
//
// Go does not use select, so it should not be subject to these limits.
// On some systems the limit is 256, which is very easy to run into,

                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to select a job by {}", id, e);
                }
                lastException = e;
                ThreadUtil.sleep(RandomUtils.nextLong(500, 5000));
            }
        }
        logger.warn("Failed to select a job by {}", id, lastException);
        return OptionalEntity.empty();
    }

    private static final String BOOLEAN_PROMPT = "thing? (default: yes) [yes, no]"
    private static final String INT_PROMPT = "thing? (min: 2, default: 3)"
    private static final String SELECT_PROMPT = "select thing:"
    private static final String QUESTION_PROMPT = "what? (default: thing):"

    def setup() {
        buildFile << """
            def handler = services.get(${UserInputHandler.name})

	// drain any retiring trackers that may be pending
	wk.drainRetiringTrackers()

	// clean up the rest
	for _, ft := range wk.watchedFiles {
		retireTracker(ft)
	}
}

func (wk *worker) loop() {
	for {
		select {
		case event := <-wk.dirWatcher.Events:
			// work on a copy of the watchedFiles map, so that we don't interfere
			// with the caller's use of the map
			for path, ft := range wk.getTrackers() {