// Range: 0 through 4294967295.
type uint32 uint32

// uint64 is the set of all unsigned 64-bit integers.
// Range: 0 through 18446744073709551615.
type uint64 uint64

// int8 is the set of all signed 8-bit integers.
// Range: -128 through 127.
type int8 int8

// int16 is the set of all signed 16-bit integers.
// Range: -32768 through 32767.
type int16 int16

// int32 is the set of all signed 32-bit integers.

			db.RowsAffected++
			db.AddError(rows.Scan(values...))

			mapValue := map[string]interface{}{}
			scanIntoMap(mapValue, values, columns)
			*dest = append(*dest, mapValue)
		}
	case *int, *int8, *int16, *int32, *int64,
		*uint, *uint8, *uint16, *uint32, *uint64, *uintptr,
		*float32, *float64,
		*bool, *string, *time.Time,
		*sql.NullInt32, *sql.NullInt64, *sql.NullFloat64,

pkg syscall (openbsd-386), type Statfs_t struct, F_fsid Fsid
pkg syscall (openbsd-386), type Statfs_t struct, F_fstypename [16]int8
pkg syscall (openbsd-386), type Statfs_t struct, F_iosize uint32
pkg syscall (openbsd-386), type Statfs_t struct, F_mntfromname [90]int8
pkg syscall (openbsd-386), type Statfs_t struct, F_mntonname [90]int8
pkg syscall (openbsd-386), type Statfs_t struct, F_namemax uint32

pkg syscall (linux-386), type Utsname struct, Domainname [65]int8
pkg syscall (linux-386), type Utsname struct, Machine [65]int8
pkg syscall (linux-386), type Utsname struct, Nodename [65]int8
pkg syscall (linux-386), type Utsname struct, Release [65]int8
pkg syscall (linux-386), type Utsname struct, Sysname [65]int8
pkg syscall (linux-386), type Utsname struct, Version [65]int8
pkg syscall (linux-386), type WaitStatus uint32

	p.start(operand)
	addr := obj.Addr{}
	p.operand(&addr)
	return addr
}

// parseScale converts a decimal string into a valid scale factor.
func (p *Parser) parseScale(s string) int8 {
	switch s {
	case "1", "2", "4", "8":
		return int8(s[0] - '0')
	}
	p.errorf("bad scale: %s", s)
	return 0
}

// operand parses a general operand and stores the result in *a.
func (p *Parser) operand(a *obj.Addr) {

	type EmbeddedPtrStruct struct {
		EmbeddedPtrIntField   int
		*NestedEmbeddedStruct `gorm:"embedded"`
	}

	type Result struct {
		BoolField          bool
		IntField           int
		Int8Field          int8
		Int16Field         int16
		Int32Field         int32
		Int64Field         int64
		UIntField          uint
		UInt8Field         uint8
		UInt16Field        uint16
		UInt32Field        uint32

func (b *block) computeChecksum() (unsigned, signed int64) {
	for i, c := range b {
		if 148 <= i && i < 156 {
			c = ' ' // Treat the checksum field itself as all spaces.
		}
		unsigned += int64(c)
		signed += int64(int8(c))
	}
	return unsigned, signed
}

// reset clears the block with all zeros.
func (b *block) reset() {
	*b = block{}
}

type headerV7 [blockSize]byte

pkg go/types, const Int16 BasicKind
pkg go/types, const Int32 = 5
pkg go/types, const Int32 BasicKind
pkg go/types, const Int64 = 6
pkg go/types, const Int64 BasicKind
pkg go/types, const Int8 = 3
pkg go/types, const Int8 BasicKind
pkg go/types, const Invalid = 0
pkg go/types, const Invalid BasicKind
pkg go/types, const IsBoolean = 1
pkg go/types, const IsBoolean BasicInfo
pkg go/types, const IsComplex = 16

		return
	}

	type Smallint int8

	type MigrateInt struct {
		Int8 Smallint
	}

	tracer := Tracer{
		Logger: DB.Config.Logger,
		Test: func(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error) {
			sql, _ := fc()
			if strings.HasPrefix(sql, "ALTER TABLE \"migrate_ints\" ALTER COLUMN \"int8\" TYPE smallint") {

        response = spy(response);
        when(response.getHeaderStart()).thenReturn(0);

        // Write FileInternalInfo data at the buffer offset
        // FileInternalInfo expects 8 bytes (IndexNumber as int8)
        SMBUtil.writeInt8(0x123456789ABCDEFL, buffer, 50);

        int result = response.readBytesWireFormat(buffer, bufferIndex);

        assertTrue(result >= 8);
        assertNotNull(response.getInfo());