kind: BGPPeer
    listKind: BGPPeerList
    plural: bgppeers
    singular: bgppeer
  scope: Namespaced
  versions:
  - additionalPrinterColumns:
    - jsonPath: .spec.peerAddress
      name: Address
      type: string
    - jsonPath: .spec.peerASN
      name: ASN
      type: string
    - jsonPath: .spec.bfdProfile
      name: BFD Profile
      type: string
    - jsonPath: .spec.ebgpMultiHop

	// arenas is the heap arena map. It points to the metadata for
	// the heap for every arena frame of the entire usable virtual
	// address space.
	//
	// Use arenaIndex to compute indexes into this array.
	//
	// For regions of the address space that are not backed by the
	// Go heap, the arena map contains nil.
	//
	// Modifications are protected by mheap_.lock. Reads can be

          .withCertificateChainCleaner(certificateChainCleaner!!)
    }

    verifyClientState()
  }

  /**
   * Creates an [Address] of out of the provided [HttpUrl]
   * that uses this client’s DNS, TLS, and proxy configuration.
   */
  fun address(url: HttpUrl): Address {
    var useSslSocketFactory: SSLSocketFactory? = null
    var useHostnameVerifier: HostnameVerifier? = null

    fi

    # Let the API server pick a default address when API_HOST_IP
    # is set to 127.0.0.1
    advertise_address=""
    if [[ "${API_HOST_IP}" != "127.0.0.1" ]]; then
        advertise_address="--advertise-address=${API_HOST_IP}"
    fi
    if [[ "${ADVERTISE_ADDRESS}" != "" ]] ; then
        advertise_address="--advertise-address=${ADVERTISE_ADDRESS}"
    fi
    node_port_range=""

//sys	VirtualUnlock(addr uintptr, length uintptr) (err error)
//sys	VirtualAlloc(address uintptr, size uintptr, alloctype uint32, protect uint32) (value uintptr, err error) = kernel32.VirtualAlloc
//sys	VirtualFree(address uintptr, size uintptr, freetype uint32) (err error) = kernel32.VirtualFree
//sys	VirtualProtect(address uintptr, size uintptr, newprotect uint32, oldprotect *uint32) (err error) = kernel32.VirtualProtect

          "active_state": {
            "listener": {
              "@type": "type.googleapis.com/envoy.config.listener.v3.Listener",
              "name": "connect_terminate",
              "address": {
                "socket_address": {
                  "address": "0.0.0.0",
                  "port_value": 15008
                }
              },
              "filter_chains": [
                {
                  "filters": [

          "active_state": {
            "listener": {
              "@type": "type.googleapis.com/envoy.config.listener.v3.Listener",
              "name": "connect_terminate",
              "address": {
                "socket_address": {
                  "address": "0.0.0.0",
                  "port_value": 15008
                }
              },
              "filter_chains": [
                {
                  "filters": [

	// unwindTrap indicates that the initial PC and SP are from a trap, not a
	// return PC from a call.
	//
	// The unwindTrap flag is updated during unwinding. If set, frame.pc is the
	// address of a faulting instruction instead of the return address of a
	// call. It also means the liveness at pc may not be known.
	//
	// TODO: Distinguish frame.continpc, which is really the stack map PC, from

}

public final class okhttp3/Route {
	public final fun -deprecated_address ()Lokhttp3/Address;
	public final fun -deprecated_proxy ()Ljava/net/Proxy;
	public final fun -deprecated_socketAddress ()Ljava/net/InetSocketAddress;
	public fun <init> (Lokhttp3/Address;Ljava/net/Proxy;Ljava/net/InetSocketAddress;)V
	public final fun address ()Lokhttp3/Address;
	public fun equals (Ljava/lang/Object;)Z
	public fun hashCode ()I

						addressesToReport = append(addressesToReport, svchost)
					}
				}
			}
		}
		// Do not report an address until we are ready. But once we are ready, never remove the address.
		if len(addressesToReport) > 0 {
			gs.Addresses = make([]k8s.GatewayStatusAddress, 0, len(addressesToReport))
			for _, addr := range addressesToReport {