new GradientTape<Gradient, BackwardFunction, TapeTensor>(false));
  AccumulatorCallState& call_state = call_state_.top();
  call_state.backward_tape = tape.get();
  auto pop_backward_tape =
      gtl::MakeCleanup([&call_state] { call_state.backward_tape = nullptr; });
  std::vector<Gradient*> forwardprop_aids;
  std::vector<int64_t> sources;
  std::unordered_set<int64_t> sources_set;

	f(func() {
		runtime.deferprocat(func() { print("A") }, #defers)
	})

For this rewriting phase, we insert the explicit initialization of
#defers and then attach the #defers variable to the CallStmt
representing the defer. That variable will be propagated to the
backend and will cause the backend to compile the defer using
deferprocat instead of an ordinary deferproc.

			//           check once we enable that again.
			p.print(n.Op, n.Op) // ++ or --
		} else {
			p.print(blank, n.Op, _Assign, blank)
			p.print(n.Rhs)
		}

	case *CallStmt:
		p.print(n.Tok, blank, n.Call)

	case *ReturnStmt:
		p.print(_Return)
		if n.Results != nil {
			p.print(blank, n.Results)
		}

	case *BranchStmt:
		p.print(n.Tok)
		if n.Label != nil {

	CAP_FEXECVE                    = 0x200000000000080
	CAP_FLOCK                      = 0x200000000010000
	CAP_FPATHCONF                  = 0x200000000020000
	CAP_FSCK                       = 0x200000000040000
	CAP_FSTAT                      = 0x200000000080000
	CAP_FSTATAT                    = 0x200000000080400
	CAP_FSTATFS                    = 0x200000000100000
	CAP_FSYNC                      = 0x200000000000100

	CAP_FEXECVE                    = 0x200000000000080
	CAP_FLOCK                      = 0x200000000010000
	CAP_FPATHCONF                  = 0x200000000020000
	CAP_FSCK                       = 0x200000000040000
	CAP_FSTAT                      = 0x200000000080000
	CAP_FSTATAT                    = 0x200000000080400
	CAP_FSTATFS                    = 0x200000000100000
	CAP_FSYNC                      = 0x200000000000100

    var dns: Dns = Dns { TODO() }

    val system: Dns = Dns.SYSTEM
  }

  @Test
  fun eventListener() {
    val eventListener =
      object : EventListener() {
        override fun callStart(call: Call) = TODO()

        override fun dnsStart(
          call: Call,
          domainName: String,
        ) = TODO()

        override fun dnsEnd(
          call: Call,

	CAP_FEXECVE                    = 0x200000000000080
	CAP_FLOCK                      = 0x200000000010000
	CAP_FPATHCONF                  = 0x200000000020000
	CAP_FSCK                       = 0x200000000040000
	CAP_FSTAT                      = 0x200000000080000
	CAP_FSTATAT                    = 0x200000000080400
	CAP_FSTATFS                    = 0x200000000100000
	CAP_FSYNC                      = 0x200000000000100

	CAP_FEXECVE                    = 0x200000000000080
	CAP_FLOCK                      = 0x200000000010000
	CAP_FPATHCONF                  = 0x200000000020000
	CAP_FSCK                       = 0x200000000040000
	CAP_FSTAT                      = 0x200000000080000
	CAP_FSTATAT                    = 0x200000000080400
	CAP_FSTATFS                    = 0x200000000100000
	CAP_FSYNC                      = 0x200000000000100

	CAP_FEXECVE                    = 0x200000000000080
	CAP_FLOCK                      = 0x200000000010000
	CAP_FPATHCONF                  = 0x200000000020000
	CAP_FSCK                       = 0x200000000040000
	CAP_FSTAT                      = 0x200000000080000
	CAP_FSTATAT                    = 0x200000000080400
	CAP_FSTATFS                    = 0x200000000100000
	CAP_FSYNC                      = 0x200000000000100

    }.also { expected ->
      assertThat(expected.message!!).startsWith("unexpected end of stream on http://")
    }

    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart", "ConnectionAcquired", "RequestHeadersStart", "RequestHeadersEnd",
      "RequestBodyStart", "RequestBodyEnd", "ResponseFailed", "ConnectionReleased", "CallFailed",
    )
    listener.clearAllEvents()