m0 map[G2]byte
			s1 G3
		}{st3.st1.st3.i1: m2[<-m4[i8_1]][st5.st1.st3.i1-st3.st1.st3.i1-i2]}
		st1 = struct {
		}{}
		pi64_0 = pi64_1
		m4 = m6
		as7 = as7
		m6[(i8_0+i8_0)&^i8_1&^i8_1] = m5[G1(96)^i8_1]
		st2 = struct {
		}{}
		st1 = struct {
		}{}
		am10 = []map[uint]int64{am9[len((*st4.pm2)[int64(65)].s0)+i], am11[st4.st1.st3.i1%st4.st1.st3.i1^i1]}
		i2 = st5.st1.st3.i1*i - st5.st1.st3.i1

// SameDisk reports whether di1 and di2 describe the same disk.
func SameDisk(disk1, disk2 string) (bool, error) {
	st1 := syscall.Stat_t{}
	st2 := syscall.Stat_t{}

	if err := syscall.Stat(disk1, &st1); err != nil {
		return false, err
	}

	if err := syscall.Stat(disk2, &st2); err != nil {
		return false, err
	}

	return st1.Dev == st2.Dev, nil

	default:
	}

	var ar, ar1 [4]func()
	switch ar { // ERROR "cannot switch on"
	case ar1:
	default:
	}

	var st, st1 struct{ f func() }
	switch st { // ERROR "cannot switch on"
	case st1:
	}
}

func good() {
	var i interface{}
	var s string

	switch i {
	case s:
	}

	switch s {
	case i:
	}

	benchmarkSwitchInterfaceType(b, false)
}

type SI0 interface {
	si0()
}
type ST0 struct {
}

func (ST0) si0() {
}

type SI1 interface {
	si1()
}
type ST1 struct {
}

func (ST1) si1() {
}

type SI2 interface {
	si2()
}
type ST2 struct {
}

func (ST2) si2() {
}

type SI3 interface {
	si3()
}
type ST3 struct {
}

	// ST1 <Vt>.H[<index_2>], [<Xn|SP>]
	{0xbfffe400, 0x0d004000, ST1, instArgs{arg_Vt_1_arrangement_H_index__Q_S_size_1, arg_Xns_mem_offset}, nil},
	// ST1 <Vt>.S[<index_3>], [<Xn|SP>]
	{0xbfffec00, 0x0d008000, ST1, instArgs{arg_Vt_1_arrangement_S_index__Q_S_1, arg_Xns_mem_offset}, nil},
	// ST1 <Vt>.D[<index_1>], [<Xn|SP>]

	VLD1 (R2), [V21.B16]                          <=>    ld1 {v21.16b}, [x2]
	VST1.P V9.S[1], (R16)(R21)                    <=>    st1 {v9.s}[1], [x16], x28
	VST1.P [V13.H8, V14.H8, V15.H8], (R3)(R14)    <=>    st1 {v13.8h-v15.8h}, [x3], x14
	VST1.P [V14.D1, V15.D1], (R7)(R23)            <=>    st1 {v14.1d, v15.1d}, [x7], x23
*/

{"Name":"ST1 (multiple structures)","Bits":"0|Q|0|0|1|1|0|0|0|0|0|0|0|0|0|0|0110:4|size:2|Rn:5|Rt:5","Arch":"No offset Three registers variant","Syntax":"ST1 { <Vt>.<T>, <Vt2>.<T>, <Vt3>.<T> }, [<Xn|SP>]","Code":"","Alias":""},
{"Name":"ST1 (multiple structures)","Bits":"0|Q|0|0|1|1|0|0|0|0|0|0|0|0|0|0|0010:4|size:2|Rn:5|Rt:5","Arch":"No offset Four registers variant","Syntax":"ST1 { <Vt>.<T>, <Vt2>.<T>, <Vt3>.<T>, <Vt4>.<T> }, [<Xn|SP>]","Code":"","Alias":""},

		}
	}
	return nil
}

// equalValueType returns true if the two value types are semantically
// equal. It ignores the internal fields used during encode/decode.
func equalValueType(st1, st2 *ValueType) bool {
	return st1.Type == st2.Type && st1.Unit == st2.Unit

		}
		if s.Addr == 0 || s.Size == 0 {
			continue
		}
		secs = append(secs, s)
	}

	secOverlaps := func(s1, s2 *elf.Section) bool {
		st1 := s1.Addr
		st2 := s2.Addr
		en1 := s1.Addr + s1.Size
		en2 := s2.Addr + s2.Size
		return max(st1, st2) < min(en1, en2)
	}

	// Sort by address
	sort.SliceStable(secs, func(i, j int) bool {
		return secs[i].Addr < secs[j].Addr
	})

		if len(args) == 0 {
			args = append(args, "st0")
		}

	case FPTAN, FSINCOS, FUCOMPP, FCOMPP, FYL2X, FPATAN, FXTRACT, FPREM1, FPREM, FYL2XP1, FSCALE:
		if len(args) == 0 {
			args = []string{"st0", "st1"}
		}

	case FST, FSTP, FISTTP, FIST, FISTP, FBSTP:
		if len(args) == 1 {
			args = append(args, "st0")
		}