func (d *dialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
	if network != "tcp" {
		return net.Dial(network, address)
	}
	// TODO: use context
	c, s := net.Pipe()
	err := d.proxyTo(s, d.cfg, address)
	if err != nil {
		return nil, err
	}
	return c, nil
}

func (d dialer) Dial(network, address string) (c net.Conn, err error) {
	return d.DialContext(context.Background(), network, address)
}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !purego

#include "textflag.h"

// func block(dig *digest, p []byte)
TEXT ·block(SB), NOSPLIT|NOFRAME, $0-32
	MOVBZ  ·useAsm(SB), R4
	LMG    dig+0(FP), R1, R3            // R2 = &p[0], R3 = len(p)
	MOVBZ  $2, R0                       // SHA-256 function code
	CMPBEQ R4, $0, generic

loop:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !purego

#include "textflag.h"

// func block(dig *digest, p []byte)
TEXT ·block(SB), NOSPLIT|NOFRAME, $0-32
	MOVBZ  ·useAsm(SB), R4
	LMG    dig+0(FP), R1, R3            // R2 = &p[0], R3 = len(p)
	MOVBZ  $3, R0                       // SHA-512 function code
	CMPBEQ R4, $0, generic

loop:

	done1 <- true
	<-done2
	select {
	case c1 <- 0:
	case c2 <- 0:
	}
	mu.Unlock()
	wg.Done()
	cv.Signal()
	c, err := net.Dial("tcp", ln.Addr().String())
	if err != nil {
		log.Fatalf("failed to dial: %v", err)
	}
	c.Close()
	var data [1]byte
	wp.Write(data[:])
	<-pipeReadDone

	oldGoMaxProcs := runtime.GOMAXPROCS(0)
	runtime.GOMAXPROCS(oldGoMaxProcs + 1)

# CHECK-DAG:       %[[VAL_2:.*]] = arith.constant dense<[1, 0]> : tensor<2xi32>
# CHECK-DAG:       %[[VAL_3:.*]] = "tfl.no_value"() <{value}> : () -> none
# CHECK-DAG:       %[[VAL_6:.*]] = arith.constant dense<0> : tensor<i32>

	"fmt"
	"net"
)

func init() {
	registerInit("NetpollDeadlock", NetpollDeadlockInit)
	register("NetpollDeadlock", NetpollDeadlock)
}

func NetpollDeadlockInit() {
	fmt.Println("dialing")
	c, err := net.Dial("tcp", "localhost:14356")
	if err == nil {
		c.Close()
	} else {
		fmt.Println("error: ", err)
	}
}

func NetpollDeadlock() {
	fmt.Println("done")

				url = fmt.Sprintf("ws://%s/portForward/%s/%s?port=%s", fw.testHTTPServer.Listener.Addr().String(), podNamespace, podName, test.port)
			}

			ws, err := websocket.Dial(url, "", "http://127.0.0.1/")
			assert.Equal(t, test.shouldError, err != nil, "websocket dial")
			if test.shouldError {
				return
			}
			defer ws.Close()

			p, err := strconv.ParseUint(test.port, 10, 16)
			require.NoError(t, err, "parse port")

	// Should have connection refused before we listen
	_, err = net.Dial("tcp", d.Address())
	assert.Error(t, err)

	assert.NoError(t, d.Listen())

	// Now we should see success
	_, err = net.Dial("tcp", d.Address())
	assert.NoError(t, err)

	assert.NoError(t, d.Close())
	// Now we should failure again success
	_, err = net.Dial("tcp", d.Address())
	assert.Error(t, err)
}

# PRUNE-SAME:  control_outputs = "AssignAdd"
# PRUNE-SAME:  inputs = ""
# PRUNE-SAME:  outputs = ""
# PRUNE-NOT:       "tf.Assign"
# PRUNE-NOT:       "tf.Identity"
# PRUNE-DAG:       %[[CONST:.*]], %{{.*}} = tf_executor.island wraps "tf.Const"
# PRUNE-DAG:       %[[VAR:.*]], %{{.*}} = tf_executor.island wraps "tf.VariableV2"
# PRUNE:           %{{.*}}, %[[ASSIGN_ADD_CTRL:.*]] = tf_executor.island wraps "tf.AssignAdd"(%[[VAR]], %[[CONST]])

    return %0 : tensor<*xf32>
  }

// CHECK-LABEL: func @conv2d
// CHECK-DAG: %[[CONST_0:.*]] = arith.constant dense<0.000000e+00> : tensor<2xf32>
// CHECK-DAG: %[[CONST_1:.*]] = arith.constant dense<3.000000e+00> : tensor<2x3x3x512xf32>