if (cacheResponse != null) {
      if (networkResponse?.code == HTTP_NOT_MODIFIED) {
        val response =
          cacheResponse.newBuilder()
            .headers(combine(cacheResponse.headers, networkResponse.headers))
            .sentRequestAtMillis(networkResponse.sentRequestAtMillis)
            .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis)

    val networkResponse = chain.proceed(networkRequest)

    cookieJar.receiveHeaders(networkRequest.url, networkResponse.headers)

    val responseBuilder =
      networkResponse.newBuilder()
        .request(networkRequest)

    if (transparentGzip &&
      "gzip".equals(networkResponse.header("Content-Encoding"), ignoreCase = true) &&
      networkResponse.promisesBody()
    ) {

fun Response.Builder.commonBody(body: ResponseBody) =
  apply {
    this.body = body
  }

fun Response.Builder.commonNetworkResponse(networkResponse: Response?) =
  apply {
    checkSupportResponse("networkResponse", networkResponse)
    this.networkResponse = networkResponse
  }

fun Response.Builder.commonCacheResponse(cacheResponse: Response?) =
  apply {
    checkSupportResponse("cacheResponse", cacheResponse)

  @JvmName("-deprecated_networkResponse")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "networkResponse"),
    level = DeprecationLevel.ERROR,
  )
  fun networkResponse(): Response? = networkResponse

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

   */
  fun networkResponse(): RecordedResponse {
    val networkResponse = response!!.networkResponse!!
    return RecordedResponse(networkResponse.request, networkResponse, null, null, null)
  }

  /** Asserts that the current response didn't use the network.  */
  fun assertNoNetworkResponse() =
    apply {
      assertThat(response!!.networkResponse).isNull()
    }

        println("Response 1 response:          $it")
        println("Response 1 cache response:    ${it.cacheResponse}")
        println("Response 1 network response:  ${it.networkResponse}")
        return@use it.body.string()
      }

    val response2Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

      System.out.println("Response 1 response:          " + response1);
      System.out.println("Response 1 cache response:    " + response1.cacheResponse());
      System.out.println("Response 1 network response:  " + response1.networkResponse());
    }

    String response2Body;
    try (Response response2 = client.newCall(request).execute()) {
      if (!response2.isSuccessful()) throw new IOException("Unexpected code " + response2);

    Request request = new Request.Builder()
        .url(url)
        .build();
    try (Response response = client.newCall(request).execute()) {
      String responseSource = response.networkResponse() != null ? ("(network: "
          + response.networkResponse().code()
          + " over "
          + response.protocol()
          + ")") : "(cache)";
      int responseCode = response.code();

      try (Response response = clientForCall.newCall(request).execute()) {
        if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

        System.out.println("    Network: " + (response.networkResponse() != null));
        System.out.println();
      }
    }
  }

  public static void main(String... args) throws Exception {
    new RewriteResponseCacheControl(new File("RewriteResponseCacheControl.tmp")).run();

        // The network response also has everything, including the raw gzipped content.
        val networkResponse = chain.proceed(networkRequest)
        assertThat(networkResponse.header("Content-Encoding")).isEqualTo("gzip")
        networkResponse
      }
    client =
      client.newBuilder()
        .addNetworkInterceptor(interceptor)
        .build()
    val request =