{decQuantity(1000000, 3, DecimalSI), "1G", ""},
		{decQuantity(1000000000, 0, DecimalSI), "1G", ""},
		{decQuantity(1, -3, DecimalSI), "1m", "1000u"},
		{decQuantity(80, -3, DecimalSI), "80m", ""},
		{decQuantity(1080, -3, DecimalSI), "1080m", "1.08"},
		{decQuantity(108, -2, DecimalSI), "1080m", "1080000000n"},
		{decQuantity(10800, -4, DecimalSI), "1080m", ""},
		{decQuantity(300, 6, DecimalSI), "300M", ""},

2	eth0      :     2      V2
				FB0000E0     1 0:00000000		1
				010000E0     1 0:00000000		0
3	eth1      :     1      V3
				010000E0     1 0:00000000		0
4	eth2      :     1      V3
				010000E0     1 0:00000000		0
5	eth0.100  :     2      V3
				FB0000E0     1 0:00000000		0
				010000E0     1 0:00000000		0
6	eth0.101  :     2      V3
				FB0000E0     1 0:00000000		0
				010000E0     1 0:00000000		0
7	eth0.102  :     2      V3

	case 3:
		return 1000
	case 4:
		return 10000
	case 5:
		return 100000
	case 6:
		return 1000000
	case 7:
		return 10000000
	case 8:
		return 100000000
	case 9:
		return 1000000000
	case 10:
		return 10000000000
	case 11:
		return 100000000000
	case 12:
		return 1000000000000
	case 13:
		return 10000000000000
	case 14:
		return 100000000000000
	case 15:

	`1_234i = 1234i`,
	`1_234_567i = 1234567i`,

	`0.i = 0i`,
	`123.i = 123i`,
	`0123.i = 123i`,

	`0.e+1i = 0i`,
	`123.E-1_0i = 123e-10i`,
	`01_23.e123i = 123e123i`,

	`1e-1000000000i = 0i`,
	`1e+1000000000i = ?`,
	`6e5518446744i = ?`,
	`-6e5518446744i = ?`,
}

func testNumbers(t *testing.T, kind token.Token, tests []string) {
	for _, test := range tests {
		a := strings.Split(test, " = ")

      "connect_timeout": 1000000000,
      "LbConfig": null
    },
    "PassthroughCluster": {
      "name": "PassthroughCluster",
      "type": 4,
      "connect_timeout": 1000000000,
      "lb_policy": 4,
      "LbConfig": null
    },
    "inbound|7070|tcplocal|s1tcp.none": {
      "name": "inbound|7070|tcplocal|s1tcp.none",
      "connect_timeout": 1000000000,
      "load_assignment": {

        "eds_config": {
          "ConfigSourceSpecifier": {
            "Ads": {}
          }
        },
        "service_name": "outbound|2000||s1tcp.none"
      },
      "connect_timeout": 1000000000,
      "circuit_breakers": {
        "thresholds": [
          {
            "max_retries": {
              "value": 1024
            }
          }
        ]
      },
      "LbConfig": null
    },

// license that can be found in the LICENSE file.

package main

const x = 6e5518446744 // ERROR "malformed constant: 6e5518446744"
const _ = x * x
const _ = 1e-1000000000

	MUL	R1, R0

	// Code stolen from compiler output for:
	//
	//	var x uint64
	//	func f() (sec uint64, nsec uint32) { return x / 1000000000, uint32(x % 1000000000) }
	//
	LSR	$1, R0, R1
	MOVD	$-8543223759426509416, R2
	UMULH	R1, R2, R1
	LSR	$28, R1, R1
	MOVD	R1, sec+0(FP)
	MOVD	$1000000000, R2
	MSUB	R1, R0, R2, R0
	MOVW	R0, nsec+8(FP)

	// See RFC 7042, Section 2.2.2.
	{"02:00:5e:10:00:00:00:01", HardwareAddr{0x02, 0x00, 0x5e, 0x10, 0x00, 0x00, 0x00, 0x01}, ""},
	{"02-00-5e-10-00-00-00-01", HardwareAddr{0x02, 0x00, 0x5e, 0x10, 0x00, 0x00, 0x00, 0x01}, ""},
	{"0200.5e10.0000.0001", HardwareAddr{0x02, 0x00, 0x5e, 0x10, 0x00, 0x00, 0x00, 0x01}, ""},

	// See RFC 4391, Section 9.1.1.
	{
		"00:00:00:00:fe:80:00:00:00:00:00:00:02:00:5e:10:00:00:00:01",
		HardwareAddr{

	SUBQ	DI, AX
	IMULQ	$100, AX

	// generated code for
	//	func f(x uint64) (uint64, uint64) { return x/1000000000, x%1000000000 }
	// adapted to reduce duplication
	MOVQ	AX, CX
	MOVQ	$1360296554856532783, AX
	MULQ	CX
	ADDQ	CX, DX
	RCRQ	$1, DX
	SHRQ	$29, DX
	MOVQ	DX, sec+0(FP)
	IMULQ	$1000000000, DX
	SUBQ	DX, CX
	MOVL	CX, nsec+8(FP)