SizeofIovec           = 0x8
	SizeofMsghdr          = 0x1c
	SizeofCmsghdr         = 0xc
)

const (
	SizeofSockFprog = 0x8
)

type PtraceRegs struct {
	Regs     [32]uint64
	Lo       uint64
	Hi       uint64
	Epc      uint64
	Badvaddr uint64
	Status   uint64
	Cause    uint64
}

type FdSet struct {
	Bits [32]int32
}

type Sysinfo_t struct {
	Uptime    int32

        (0..1000).join("-")              | _
    }

    def "decode fails when string cannot be fully read"() {
        given:
        def bytes = truncate { Encoder encoder ->
            encoder.writeString("hi")
        }

        when:
        decode(bytes) { Decoder decoder ->
            decoder.readString()
        }

        then:
        thrown(EOFException)
    }

	SizeofMsghdr          = 0x38
	SizeofCmsghdr         = 0x10
)

const (
	SizeofSockFprog = 0x10
)

type PtraceRegs struct {
	Regs     [32]uint64
	Lo       uint64
	Hi       uint64
	Epc      uint64
	Badvaddr uint64
	Status   uint64
	Cause    uint64
}

type FdSet struct {
	Bits [16]int64
}

type Sysinfo_t struct {
	Uptime    int64

        "'value1'"           | "['value1']"
        "'value1'"           | "null"
        "null"               | "123"
        "[123]"              | "123"
        "false"              | "12.3"
        "[345, 'hi'] as Set" | "[345, 'hi']"
        "file('1')"          | "files('1')"
        "123"                | "123L"
        "123"                | "123 as short"
    }

    @Requires(IntegTestPreconditions.IsEmbeddedExecutor)

00000030  16 03 03 00 20 a1 58 d5  1a a3 9f 85 4e b6 c8 b7  |.... .X.....N...|
00000040  cb c1 b0 cc 0a 80 59 1d  81 41 cc 4d 0b d3 bd 38  |......Y..A.M...8|
00000050  48 69 01 23 96                                    |Hi.#.|
>>> Flow 4 (server to client)
00000000  14 03 03 00 01 01 16 03  03 00 20 83 ae fc 0d dd  |.......... .....|
00000010  a1 3a 55 b0 2e 5e 21 9c  57 f3 1b 94 80 6c 0e bb  |.:U..^!.W....l..|

}

// norm returns nhi, nlo such that
//
//	hi * base + lo == nhi * base + nlo
//	0 <= nlo < base
func norm(hi, lo, base int) (nhi, nlo int) {
	if lo < 0 {
		n := (-lo-1)/base + 1
		hi -= n
		lo += n * base
	}
	if lo >= base {
		n := lo / base
		hi += n
		lo -= n * base
	}
	return hi, lo
}

// Date returns the Time corresponding to
//

00000090  2d 10 e3 e5 1d 1b 1e a9  5f 90 ca 0d a9 52 33 86  |-......._....R3.|
000000a0  85 17 03 03 02 6d ac 6a  a1 8f 42 27 74 80 25 f9  |.....m.j..B't.%.|
000000b0  1f 48 49 2d c2 33 38 e7  93 7e b0 b2 50 b8 6a ea  |.HI-.38..~..P.j.|
000000c0  a6 81 ef 9b 55 83 4e 93  df 92 97 6f 00 f5 c4 fc  |....U.N....o....|
000000d0  ec b1 19 dd 68 b5 bd c4  bb ba 63 9a e4 c9 24 af  |....h.....c...$.|

	{"and undef", "{{and 1 .Unknown}}", "<no value>", nil, true},
	{"or undef", "{{or 0 .Unknown}}", "<no value>", nil, true},
	{"boolean if", "{{if and true 1 `hi`}}TRUE{{else}}FALSE{{end}}", "TRUE", tVal, true},
	{"boolean if not", "{{if and true 1 `hi` | not}}TRUE{{else}}FALSE{{end}}", "FALSE", nil, true},
	{"boolean if pipe", "{{if true | not | and 1}}TRUE{{else}}FALSE{{end}}", "FALSE", nil, true},

	// Indexing.

// It reports whether the read was successful.
func readUint64(s *cryptobyte.String, out *uint64) bool {
	var hi, lo uint32
	if !s.ReadUint32(&hi) || !s.ReadUint32(&lo) {
		return false
	}
	*out = uint64(hi)<<32 | uint64(lo)
	return true
}

// readUint8LengthPrefixed acts like s.ReadUint8LengthPrefixed, but targets a
// []byte instead of a cryptobyte.String.

000002a0  81 0a 04 03 00 8a 30 81  87 02 42 01 fb 16 53 43  |......0...B...SC|
000002b0  2b 86 61 0a 58 a0 68 c1  cd 2c ff ec 79 7f 83 fa  |+.a.X.h..,..y...|
000002c0  cc 0b 24 9d 98 54 d0 dc  90 55 e1 b3 e6 48 69 1a  |..$..T...U...Hi.|
000002d0  55 62 f4 da 8f 60 db f7  76 80 d5 4d 37 f6 43 49  |Ub...`..v..M7.CI|
000002e0  95 3d 96 f6 e2 fd a4 07  ae 24 8c fa bd 02 41 20  |.=.......$....A |