}()
	defer g()
	x = deflt
	return
}

func test5() {
	v := try(func() { panic(5) }, 55).(int)
	if v != 5 {
		println("wrong value", v, 5)
		die()
	}

	s := try(func() {}, "hi").(string)
	if s != "hi" {
		println("wrong value", s, "hi")
		die()
	}

	v = try1(func() { panic(5) }, 55).(int)
	if v != 5 {
		println("try1 wrong value", v, 5)
		die()
	}

        where:
        constantType | constantValue   | newValue
        'boolean'    | 'false'         | 'true'
        'byte'       | '(byte) 125'    | '(byte) 126'
        'short'      | '(short) 666'   | '(short) 555'
        'int'        | '55542'         | '444'
        'long'       | '5L'            | '689L'
        'float'      | '6f'            | '6.5f'
        'double'     | '7d'            | '7.2d'

     *     <td>write &amp; execute</td>
     *   </tr>
     *   <tr>
     *     <td>444</td>
     *     <td>r--r--r--</td>
     *     <td>read</td>
     *   </tr>
     *   <tr>
     *     <td>555</td>
     *     <td>r-xr-xr-x</td>
     *     <td>read &amp; execute</td>
     *   </tr>
     *   <tr>
     *     <td>666</td>
     *     <td>rw-rw-rw-</td>
     *     <td>read &amp; write</td>

	}

	updatedCronJob := &batch.CronJob{
		ObjectMeta: metav1.ObjectMeta{Name: "bar", ResourceVersion: "4"},
		Spec: batch.CronJobSpec{
			Schedule: "5 5 5 * ?",
		},
		Status: batch.CronJobStatus{
			LastScheduleTime: &now,
		},
	}

	// ensure we do not change status
	Strategy.PrepareForUpdate(ctx, updatedCronJob, cronJob)

			rawNodeIPs: []net.IP{
				netutils.ParseIPSloppy("90.90.90.90"),
				netutils.ParseIPSloppy("2001:db8::2"),
			},
			bindAddress:    "2001:db8::555",
			expectedFamily: v1.IPv6Protocol,
			expectedIPv4:   "90.90.90.90",
			expectedIPv6:   "2001:db8::555",
		},
		{
			name: "Dual stack, override primary family, IPv4",
			rawNodeIPs: []net.IP{
				netutils.ParseIPSloppy("2001:db8::2"),

						PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
							ClaimName: "claimA",
						},
					},
				},
			},
			SecurityContext: &v1.PodSecurityContext{
				SupplementalGroups: []int64{555},
			},
		},
	}
	switch podMode {
	case v1.PersistentVolumeBlock:
		pod.Spec.Containers[0].VolumeDevices = []v1.VolumeDevice{
			{
				Name:       "vol1",
				DevicePath: "/dev/vol1",
			},

    font-weight: normal;
}

tfoot {
    font-style: italic;
}

caption {
    background: #eee;
}

abbr, acronym {
    font-size: 85%;
    font-weight: bold;
    color: #555;
    text-transform: uppercase;
}

abbr[title], acronym[title] {
    cursor: help;
    border-bottom: 1px dotted #e5e5e5;
}

b, strong, dfn {
    font-weight: 700;
}

em, dfn {

	case 549:
		return 549
	case 550:
		return 550
	case 551:
		return 551
	case 552:
		return 552
	case 553:
		return 553
	case 554:
		return 554
	case 555:
		return 555
	case 556:
		return 556
	case 557:
		return 557
	case 558:
		return 558
	case 559:
		return 559
	case 560:
		return 560
	case 561:
		return 561
	case 562:

	SYS_FSTATAT                  = 552 // { int fstatat(int fd, _In_z_ char *path, \
	SYS_GETDIRENTRIES            = 554 // { ssize_t getdirentries(int fd, \
	SYS_STATFS                   = 555 // { int statfs(_In_z_ char *path, \
	SYS_FSTATFS                  = 556 // { int fstatfs(int fd, \
	SYS_GETFSSTAT                = 557 // { int getfsstat( \

	q := -mulByLog2Log10(e2+54) + prec - 1

	// Now compute mant*(2^e2)*(10^q).
	// Is it an exact computation?
	// Only small positive powers of 10 are exact (5^55 has 128 bits).
	exact := q <= 55 && q >= 0

	di, dexp2, d0 := mult128bitPow10(mant, e2, q)
	if dexp2 >= 0 {
		panic("not enough significant bits after mult128bitPow10")
	}