fmt.Fprintf(os.Stderr, "# get %s: %v (%.3fs)\n", fetched.Redacted(), res.Status, time.Since(start).Seconds())
	}

	r := &Response{
		URL:        fetched.Redacted(),
		Status:     res.Status,
		StatusCode: res.StatusCode,
		Header:     map[string][]string(res.Header),
		Body:       res.Body,
	}

	if res.StatusCode != http.StatusOK {
		contentType := res.Header.Get("Content-Type")

				if i > 0 {
					res = append(res, &md.Plain{Text: text[:i]})
				}
				res = append(res, &md.Plain{Text: text[i : i+1]})
				text = text[i+1:]
			}
		} else {
			res = append(res, in)
		}
	}
	return res
}

// symbolLinkText returns the text of a possible symbol link.
// It is given a slice of Inline elements and an index into the slice.

package httpresponse

import (
	"log"
	"net/http"
)

func goodHTTPGet() {
	res, err := http.Get("http://foo.com")
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()
}

func badHTTPGet() {
	res, err := http.Get("http://foo.com")
	defer res.Body.Close() // ERROR "using res before checking for errors"
	if err != nil {
		log.Fatal(err)
	}

    void testCompileClasspathTransform() throws Exception {
        ClasspathContainer res;

        res = transform.transform(graph, ArtifactScopeEnum.compile, false);

        assertNotNull(res, "null classpath container after compile transform");
        assertNotNull(res.getClasspath(), "null classpath after compile transform");
        assertEquals(3, res.getClasspath().size(), "compile classpath should have 3 entries");
    }

		{"A/B", res("A", "B")},
		{"A/B/", res("A", "B", "")},
		{"/A/B/", res("", "A", "B", "")},
		{"[A]/(B)", res("[A]", "(B)")},
		{"[/]/[/]", res("[/]", "[/]")},
		{"[/]/[:/]", res("[/]", "[:/]")},
		{"/]", res("", "]")},
		{"]/", res("]", "")},
		{"]/[/]", res("]", "[/]")},
		{`([)/][(])`, res(`([)/][(])`)},
		{"[(]/[)]", res("[(]", "[)]")},

		{"A/B|C/D", alt(res("A", "B"), res("C", "D"))},

		// Faulty patterns

	res := map[string]*route.RouteConfiguration{}
	for _, l := range rc {
		res[l.Name] = l
	}
	return res
}

func ExtractListenerFilters(l *listener.Listener) map[string]*listener.ListenerFilter {
	res := map[string]*listener.ListenerFilter{}
	for _, lf := range l.ListenerFilters {
		res[lf.Name] = lf
	}
	return res
}

def LiftBatchMatMul : Pat<
  (TF_BatchMatMulV2Op:$res $x, $y, $adj_x, $adj_y, $grad_x, $grad_y),
  (LiftAsTFPartitionedCall<"composite_batch_matmul_fn">
    (ArgumentList $x, $y),
    (ResultList $res),
    (NamedAttributeList
      (NamedAttr<"adj_x"> $adj_x),
      (NamedAttr<"adj_y"> $adj_y))),
  [(IsNotInLiftedFunc $res)], [], (addBenefit 1)>;

def LiftEinsum : Pat<

		l := NewWithRetry(func() (int32, error) {
			res := computations.Inc()
			if res > 2 {
				return res, nil
			}

			return res, fmt.Errorf("not yet")
		})
		res, err := l.Get()
		assert.Error(t, err)
		assert.Equal(t, res, 1)

		res, err = l.Get()
		assert.Error(t, err)
		assert.Equal(t, res, 2)

		res, err = l.Get()
		assert.NoError(t, err)
		assert.Equal(t, res, 3)
	})

    (ArgumentList $lhs, $rhs, $bias),
    (ResultList $res),
    (NamedAttributeList
      (NamedAttr<"dot_dimension_numbers"> $dot_dimension_numbers),
      (NamedAttr<"precision_config"> (DefaultOrNullAttr $precision_config)))),
  [(IsNotInLiftedFunc $res), (IsStableHLOConstantOp $bias)], [], (addBenefit 5)>;

def LiftConvWithBiasDynamic : Pat<
  (StableHLO_AddOp:$res

			results = append(results, cachedItem)
			cached++
			continue
		}
		regenerated++
		res := s.generate(sr, configClusterSecrets, proxyClusterSecrets, proxy)
		if res != nil {
			s.cache.Add(sr, req, res)
			results = append(results, res)
		}
	}
	return results, model.XdsLogDetails{
		Incremental:    updatedSecrets != nil,