00000120  79 c5 9c 78 68 5f 20 12  01 06 c3 52 49 66 e4 5b  |y..xh_ ....RIf.[|
00000130  41 09 fa 72 c5 d7 d9 26  1b fa a5 1d 23 b2 4a 1e  |A..r...&....#.J.|
00000140  da 83 5e 89 c8 3a c4 26  f2 42 70 6d 1b 90 67 eb  |..^..:.&.Bpm..g.|
00000150  37 15 35 b9 a2 b0 2b ef  93 5f 11 17 03 03 00 59  |7.5...+.._.....Y|
00000160  b4 a0 79 ba e4 3f 78 d2  11 1a 71 8a a1 a4 28 fc  |..y..?x...q...(.|

>>> Flow 4 (server to client)
00000000  14 03 01 00 01 01 16 03  01 00 30 3d a8 df 2e 80  |..........0=....|
00000010  26 22 66 32 fb 6e bc 9e  f5 d6 6a 5e 0a 18 34 92  |&"f2.n....j^..4.|
00000020  f9 42 40 e4 9c b1 7a 28  d2 52 e9 b8 13 ce 89 01  |.B@...z(.R......|
00000030  23 44 ab 2e 75 3e c2 96  f5 59 61                 |#D..u>...Ya|
>>> Flow 5 (client to server)

func stack4240() { var buf [4240]byte; use(buf[:]); C.callGoStackCheck() }
func stack4244() { var buf [4244]byte; use(buf[:]); C.callGoStackCheck() }
func stack4248() { var buf [4248]byte; use(buf[:]); C.callGoStackCheck() }
func stack4252() { var buf [4252]byte; use(buf[:]); C.callGoStackCheck() }
func stack4256() { var buf [4256]byte; use(buf[:]); C.callGoStackCheck() }
func stack4260() { var buf [4260]byte; use(buf[:]); C.callGoStackCheck() }

#define SYS_rt_sigaction	4194
#define SYS_rt_sigprocmask	4195
#define SYS_sigaltstack		4206
#define SYS_madvise		4218
#define SYS_mincore		4217
#define SYS_gettid		4222
#define SYS_futex		4238
#define SYS_sched_getaffinity	4240
#define SYS_exit_group		4246
#define SYS_timer_create	4257
#define SYS_timer_settime	4258
#define SYS_timer_delete	4261
#define SYS_clock_gettime	4263
#define SYS_tgkill		4266
#define SYS_pipe2		4328

00000310  88 aa 46 a2 d3 7b 65 56  e2 77 72 df              |..F..{eV.wr.|
>>> Flow 4 (server to client)
00000000  14 03 03 00 01 01 16 03  03 00 40 b8 19 a7 e2 35  |..........@....5|
00000010  8a be 5f 4c 91 d2 db 3f  f3 42 90 8e b5 7f ea f7  |.._L...?.B......|
00000020  52 3e 61 2f 4d ef 25 8d  ce 82 77 22 05 6f 0d b6  |R>a/M.%...w".o..|
00000030  04 c1 f0 f0 a2 9d bf 80  a9 f5 e1 62 5c e2 30 ef  |...........b\.0.|

	/*4198*/ uint16(xArgXmm2M128),
	/*4199*/ uint16(xMatch),
	/*4200*/ uint16(xSetOp), uint16(CVTSD2SS),
	/*4202*/ uint16(xReadSlashR),
	/*4203*/ uint16(xArgXmm1),
	/*4204*/ uint16(xArgXmm2M64),
	/*4205*/ uint16(xMatch),
	/*4206*/ uint16(xSetOp), uint16(CVTSS2SD),
	/*4208*/ uint16(xReadSlashR),
	/*4209*/ uint16(xArgXmm1),
	/*4210*/ uint16(xArgXmm2M32),
	/*4211*/ uint16(xMatch),

)

const (
	reconcilerLoopPeriod          = 10 * time.Millisecond
	syncLoopPeriod                = 100 * time.Minute
	maxWaitForUnmountDuration     = 50 * time.Millisecond
	maxLongWaitForUnmountDuration = 4200 * time.Second
	volumeAttachedCheckTimeout    = 5 * time.Second
)

var registerMetrics sync.Once

// Calls Run()
// Verifies there are no calls to attach or detach.
func Test_Run_Positive_DoNothing(t *testing.T) {

	fmt.Printf("There are %d nanoseconds in %v.\n", micro.Nanoseconds(), micro)
	fmt.Printf("There are %6.2e seconds in %v.\n", micro2.Seconds(), micro2)
	// Output:
	// 10h0m0s
	// 1h10m10s
	// There are 4210 seconds in 1h10m10s.
	// There are 1000 nanoseconds in 1µs.
	// There are 1.00e-06 seconds in 1µs.
}

func ExampleDuration_Hours() {
	h, _ := time.ParseDuration("4h30m")

  %40 = mhlo.subtract %39, %37 : tensor<1x64x32x32xf32>
  %41 = mhlo.multiply %40, %28 : tensor<1x64x32x32xf32>
  %42 = mhlo.add %37, %41 : tensor<1x64x32x32xf32>
  %43 = mhlo.subtract %42, %30 : tensor<1x64x32x32xf32>
  %44 = "mhlo.broadcast_in_dim"(%0) <{broadcast_dimensions = dense<[2, 3]> : tensor<2xi64>}> : (tensor<32x1xf32>) -> tensor<1x64x32x1xf32>

		if len(hs.clientHello.pskIdentities) == 0 {
			c.sendAlert(alertIllegalParameter)
			return errors.New("tls: early_data without pre_shared_key")
		}
	} else if hs.clientHello.earlyData {
		// See RFC 8446, Section 4.2.10 for the complicated behavior required
		// here. The scenario is that a different server at our address offered
		// to accept early data in the past, which we can't handle. For now, all