CheckRedirect: redirectChecker(),
			}
		}
	}

	return s, nil
}

// Copies logic from https://github.com/kubernetes/kubernetes/blob/b152001f459/pkg/probe/http/http.go#L129-L130
func isRedirect(code int) bool {
	return code >= http.StatusMultipleChoices && code < http.StatusBadRequest
}

    level = DeprecationLevel.ERROR,
  )
  fun body() = body

  fun newBuilder(): Builder = commonNewBuilder()

  /** Returns true if this response redirects to another resource. */
  val isRedirect: Boolean = commonIsRedirect

  @JvmName("-deprecated_networkResponse")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "networkResponse"),

		for code := http.StatusOK; code <= http.StatusNetworkAuthenticationRequired; code++ {
			if http.StatusText(code) == "" { // Not a valid HTTP code
				continue
			}
			expect := code
			if isRedirect(code) {
				expect = 200
			}
			t.Run(fmt.Sprint(code), func(t *testing.T) {
				testFn(t, test{
					probePath: "app-health/code/livez",
					config: KubeAppProbers{
						"/app-health/code/livez": &Prober{

    val peekBody: ResponseBody = response.peekBody(0L)
    val body: ResponseBody = response.body
    val builder: Response.Builder = response.newBuilder()
    val redirect: Boolean = response.isRedirect
    val networkResponse: Response? = response.networkResponse
    val cacheResponse: Response? = response.cacheResponse
    val priorResponse: Response? = response.priorResponse

	public final fun headers ()Lokhttp3/Headers;
	public final fun headers (Ljava/lang/String;)Ljava/util/List;
	public final fun isRedirect ()Z
	public final fun isSuccessful ()Z
	public final fun message ()Ljava/lang/String;
	public final fun networkResponse ()Lokhttp3/Response;
	public final fun newBuilder ()Lokhttp3/Response$Builder;

		}
		// Does it involve an indirection?
		nlast := ns[len(ns)-1]
		nprev := 1
		if len(ns) > 1 {
			nprev = ns[len(ns)-2]
		}
		isIndirect := false
		for n := nlast / 2; n > nprev; n /= 2 {
			if n%2 == 1 {
				isIndirect = true
				break
			}
		}
		fmt.Print(")")
		if isIndirect {
			fmt.Print(` // ERROR "indirection|embedded via a pointer"`)
		}
		fmt.Print("\n")
	}

        byte[] stub, frag;
        NdrBuffer buf, fbuf;
        boolean isLast, isDirect;
        DcerpcException de;

        if (state == 0) {
            bind();
        }

        isDirect = true;

        stub = jcifs.smb1.smb1.BufferCache.getBuffer();
        try {
            int off, tot, n;

require (
	direct v0.0.0
	example.com/lazyupgrade v0.1.0
)

replace (
	direct => ./direct
	example.com/lazyupgrade v0.1.0 => ./lazyupgrade@v0.1.0
	example.com/lazyupgrade v0.1.1 => ./lazyupgrade@v0.1.1
)
-- usedirect/usedirect.go --
package use

import _ "example.com/lazyupgrade"
-- useindirect/useindirect.go --
package use

import _ "direct"
-- direct/go.mod --
module direct

go 1.17

                    boolean isDirect) throws IOException {
        if (out != null && out.isOpen() == false)
            throw new IOException("DCERPC pipe is no longer open");

        if (in == null)
            in = (SmbFileInputStream)pipe.getNamedPipeInputStream();
        if (out == null)
            out = (SmbFileOutputStream)pipe.getNamedPipeOutputStream();
        if (isDirect) {

		}
	}

	realPkgPath := unmassage(pkg.PkgPath)

	direct, indirect := transitiveImports(pkg)
	isDirect := map[string]bool{}
	for _, imp := range direct {
		isDirect[imp] = true
	}
	relate := func(imp string) string {
		if isDirect[imp] {
			return "->"
		}
		return "-->"
	}

	var errs []error
	for _, imp := range uniq(direct, indirect) {