// This is an optimized version of the sample code in the PNG spec.
	// For example, the sample code starts with:
	//	p := int(a) + int(b) - int(c)
	//	pa := abs(p - int(a))
	// but the optimized form uses fewer arithmetic operations:
	//	pa := int(b) - int(c)
	//	pa = abs(pa)
	pc := int(c)
	pa := int(b) - pc
	pb := int(a) - pc
	pc = abs(pa + pb)
	pa = abs(pa)
	pb = abs(pb)
	if pa <= pb && pa <= pc {
		return a

            Element simplelist = document.createElement("simplelist");

            int columns = 3;
            if (classDoc.getSubClasses().size() <= 3) {
                // if there are only 3 or fewer known subtypes, render them
                // in a single column
                columns = 1;
            }
            simplelist.setAttribute("columns", String.valueOf(columns));

	// It is first in the struct because it is used in the hot path.
	// The hot path is inlined at every call site.
	// Placing done first allows more compact instructions on some architectures (amd64/386),
	// and fewer instructions (to calculate offset) on other architectures.
	done atomic.Uint32
	m    Mutex
}

// Do calls the function f if and only if Do is being called for the

        then:
        def ex = thrown(IllegalArgumentException)
        ex.message == "'more.than.two.dots' is an invalid pattern. Patterns should have one or two dots."
    }

    def "can use filters with two dots or fewer"() {
        when:
        select('one.dot', 'has.two.dots', 'ModuleName')

        then:
        noExceptionThrown()
    }

    def "converts second dot into slash"() {
        expect:

func (lb *unweightedLeastRequest) Request(onDone func()) {
	if len(lb.conns) == 1 {
		lb.doRequest(lb.get(0), onDone)
		return
	}

	// Pick 2 endpoints at random.
	c1, c2 := lb.pick2()

	// Choose the endpoint with fewer active requests.
	selected := c1
	if c2.ActiveRequests() < c1.ActiveRequests() {
		selected = c2
	}

	// Apply the selected endpoint to the metrics decorator and send the request.
	lb.doRequest(selected, onDone)
}

    This could happen if another process is removing count files. In this
    case there is already a YYYY-MM-DD.json file either in localdir
    or updatedir, so the process seeing fewer count files will not generate
    a report.
1B. They could see the same count files, and no report in either directory.
    They will both generate (in memory) reports and check to see if there

   * this address.
   *
   * If [planToReplace] is non-null, this will swap it for a pooled connection if that pooled
   * connection uses HTTP/2. That results in fewer sockets overall and thus fewer TCP slow starts.
   */
  internal fun planReusePooledConnection(
    planToReplace: ConnectPlan? = null,
    routes: List<Route>? = null,
  ): ReusePlan? {
    val result =

   * Returns {@code true} if each element in {@code iterable} after the first is greater than or
   * equal to the element that preceded it, according to the specified comparator. Note that this is
   * always true when the iterable has fewer than two elements.
   */
  public static <T extends @Nullable Object> boolean isInOrder(
      Iterable<? extends T> iterable, Comparator<T> comparator) {
    checkNotNull(comparator);

// isn't granular enough to get useful information out of a trace in
// many cases.
//
// This makes absolute values of timestamp diffs smaller, and so they are
// encoded in fewer bytes.
//
// The target resolution in all cases is 64 nanoseconds.
// This is based on the fact that fundamentally the execution tracer won't emit
// events more frequently than roughly every 200 ns or so, because that's roughly

	fmt.Fprintln(w, "// into 4×4×4 subdivision, with 4 shades in each subcube. Compared to the")
	fmt.Fprintln(w, "// WebSafe, the idea is to reduce the color resolution by dicing the")
	fmt.Fprintln(w, "// color cube into fewer cells, and to use the extra space to increase the")
	fmt.Fprintln(w, "// intensity resolution. This results in 16 gray shades (4 gray subcubes with")