00000020  43 9c 9a be c9 93 b9 e1  9f 42 74 20 5d a2 d5 2d  |C........Bt ]..-|
00000030  d6 9f 76 0c 14 dd e0 d3  71 a6 44 6a bc 3c ff a5  |..v.....q.Dj.<..|
00000040  97 49 56 e0 3f 5b 47 87  31 83 1f 80 00 04 13 01  |.IV.?[G.1.......|
00000050  00 ff 01 00 01 0f 00 0b  00 04 03 00 01 02 00 0a  |................|
00000060  00 06 00 04 00 1d 00 17  00 23 00 00 00 16 00 00  |.........#......|
00000070  00 17 00 00 00 0d 00 1e  00 1c 04 03 05 03 06 03  |................|

00000080  1f a9 7f 82 3a d9 46 d9  d8 b8 77 65 e8 b3 e7 f5  |....:.F...we....|
00000090  15 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
000000a0  00 00 00 00 00 6d 29 d4  87 0a b4 1d b4 9d f4 12  |.....m).........|
000000b0  bc 3d a3 1b 79 21 85 0d  e7 10 64 92 40 39 05 99  |.=..y!....d.@9..|

00000080  28 ca 01 68 ab ad ba ee  6c 6a 19 0b e5 6d 82 24  |(..h....lj...m.$|
00000090  15 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
000000a0  00 00 00 00 00 fc 07 f4  d4 bb 24 a3 f1 cf dc 3c  |..........$....<|
000000b0  ac 14 63 50 32 34 fd 73  c0 eb f2 78 7b 3b ea 58  |..cP24.s...x{;.X|

	// Max stack size is 1 GB on 64-bit, 250 MB on 32-bit.
	// Using decimal instead of binary GB and MB because
	// they look nicer in the stack overflow failure message.
	if goarch.PtrSize == 8 {
		maxstacksize = 1000000000
	} else {
		maxstacksize = 250000000
	}

	// An upper limit for max stack size. Used to avoid random crashes
	// after calling SetMaxStack and trying to allocate a stack that is too big,

	{"2021-09-29T16:04:33.1000000009Z", 100_000_000},
	{"2021-09-29T16:04:33.9999999999Z", 999_999_999},
	{"2021-09-29T16:04:33.0123456789Z", 12_345_678},
	// 11 digits, truncates
	{"2021-09-29T16:04:33.10000000000Z", 100_000_000},
	{"2021-09-29T16:04:33.00123456789Z", 1_234_567},
	// 12 digits, truncates
	{"2021-09-29T16:04:33.000123456789Z", 123_456},
	// 15 digits, truncates

				return false
			}
		} else {
			if d[i].b >= lastB {
				return false
			}
		}
		lastB = d[i].b
	}
	return true
}

func TestStability(t *testing.T) {
	n, m := 100000, 1000
	if testing.Short() {
		n, m = 1000, 100
	}
	data := make(intPairs, n)

	// random distribution
	for i := 0; i < len(data); i++ {
		data[i].a = rand.Intn(m)
	}

		Precedence: 50,
		Label:      0,
	},
	{
		// "::ffff:0:0/96"
		// IPv4-compatible, etc.
		Prefix:     netip.PrefixFrom(netip.AddrFrom16([16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}), 96),
		Precedence: 35,
		Label:      4,
	},
	{
		// "::/96"
		Prefix:     netip.PrefixFrom(netip.AddrFrom16([16]byte{}), 96),
		Precedence: 1,
		Label:      3,
	},
	{

00000080  59 00 e8 dc a5 a1 6f 76  e2 e9 f2 e1 21 58 6b a0  |Y.....ov....!Xk.|
00000090  15 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
000000a0  00 00 00 00 00 3c 6e a7  81 36 d0 8c 99 d8 f3 55  |.....<n..6.....U|
000000b0  02 2e 1a 48 2d 5c 46 6e  ff f2 17 f2 d4 60 b5 9e  |...H-\Fn.....`..|

	if oldval == -1 { // starting
		oldval = 0
	}
	if phase == 0 {
		return oldval
	}
	if oldval+p.Spadj < -10000 || oldval+p.Spadj > 1100000000 {
		ctxt.Diag("overflow in spadj: %d + %d = %d", oldval, p.Spadj, oldval+p.Spadj)
		ctxt.DiagFlush()
		log.Fatalf("bad code")
	}

	return oldval + p.Spadj
}

  @VisibleForTesting
  static final long[] powersOf10 = {
    1L,
    10L,
    100L,
    1000L,
    10000L,
    100000L,
    1000000L,
    10000000L,
    100000000L,
    1000000000L,
    10000000000L,
    100000000000L,
    1000000000000L,
    10000000000000L,
    100000000000000L,
    1000000000000000L,
    10000000000000000L,
    100000000000000000L,