} else if got.ID != u1.ID {
			t.Fatalf("select expects: %v, got %v", u1, got)
		}

		u1.Name = "jinzhu"
		if results := DB.Save(&u1); results.Error != nil {
			t.Fatalf("errors happened on update: %v", results.Error)
		} else if results.RowsAffected != 1 {
			t.Fatalf("rows affected expects: %v, got %v", 1, results.RowsAffected)
		}

	if x != 0 {
		return 1
	}
	return 0
	// branchless:
	// return 1 - ((x>>1|x&1)-1)>>63
}

func shl(u1, u2 uint64, n uint) (r1, r2 uint64) {
	r1 = u1<<n | u2>>(64-n) | u2<<(n-64)
	r2 = u2 << n
	return
}

func shr(u1, u2 uint64, n uint) (r1, r2 uint64) {
	r2 = u2>>n | u1<<(64-n) | u1>>(n-64)
	r1 = u1 >> n
	return
}

// shrcompress compresses the bottom n+1 bits of the two-word

	// 
	type T4 struct{}

	// T4.M should appear as method of T5 only if AllMethods is set. 
	func (*T4) M()

	// 
	type T5 struct {
		T4
	}

	// 
	type U1 struct {
		*U1
	}

	// U1.M should appear as method of U1. 
	func (*U1) M()

	// 
	type U2 struct {
		*U3
	}

	// U2.M should appear as method of U2 and as method of U3 only if ...
	func (*U2) M()

	// 
	type U3 struct {

	// 
	type T4 struct{}

	// T4.M should appear as method of T5 only if AllMethods is set. 
	func (*T4) M()

	// 
	type T5 struct {
		T4
	}

	// 
	type U1 struct {
		*U1
	}

	// U1.M should appear as method of U1. 
	func (*U1) M()

	// 
	type U2 struct {
		*U3
	}

	// U2.M should appear as method of U2 and as method of U3 only if ...
	func (*U2) M()

	// 
	type U3 struct {

type T5 struct {
	T4
}

// ----------------------------------------------------------------------------
// Recursive type declarations must not lead to endless recursion.

type U1 struct {
	*U1
}

// U1.M should appear as method of U1.
func (*U1) M() {}

type U2 struct {
	*U3
}

// U2.M should appear as method of U2 and as method of U3 only if AllMethods is set.
func (*U2) M() {}

type U3 struct {
	*U2

	s6 := "fox" // ERROR "moved to heap: s6$"
	ps2 := &s2
	ps4 := &s4 // ERROR "moved to heap: ps4$"
	ps6 := &s6 // ERROR "moved to heap: ps6$"
	u1 := U{&s1, &ps2}
	u2 := &U{&s3, &ps4}  // ERROR "&U{...} does not escape$"
	u3 := &U{&s5, &ps6}  // ERROR "&U{...} escapes to heap$"
	v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$"
	Ssink = v.UPiSPa()   // Ssink = &s3 (only &s3 really escapes)
}

	s6 := "fox" // ERROR "moved to heap: s6$"
	ps2 := &s2
	ps4 := &s4 // ERROR "moved to heap: ps4$"
	ps6 := &s6 // ERROR "moved to heap: ps6$"
	u1 := U{&s1, &ps2}
	u2 := &U{&s3, &ps4}  // ERROR "&U{...} does not escape$"
	u3 := &U{&s5, &ps6}  // ERROR "&U{...} escapes to heap$"
	v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$"
	Ssink = v.UPiSPa()   // Ssink = &s3 (only &s3 really escapes)
}

		t1 := *(*T)(unsafe.Pointer(&T1{1, 2, 3}))
		t2 := *(*T)(unsafe.Pointer(&T1{4, 5, 6}))
		if t1 != t2 {
			panic("T{} != T{}")
		}

		var u1, u2 interface{}
		u1 = *(*U)(unsafe.Pointer(&T1{1, 2, 3}))
		u2 = *(*U)(unsafe.Pointer(&T1{4, 5, 6}))
		if u1 != u2 {
			panic("U{} != U{}")
		}
	}

	h(a, b)

	m()
}

type I interface {
	M(_ int, y int)
}

type TI struct{}

	func (*T4) M()

	// 
	type T5 struct {
		T4
	}

	// T4.M should appear as method of T5 only if AllMethods is set. 
	func (*T5) M()

	// 
	type U1 struct {
		*U1
	}

	// U1.M should appear as method of U1. 
	func (*U1) M()

	// 
	type U2 struct {
		*U3
	}

	// U2.M should appear as method of U2 and as method of U3 only if ...
	func (*U2) M()

// Some more cases.

type M interface { m() }
type M32 interface { m() int32 }
type M64 interface { m() int64 }

type U1 interface { m() }
type U2 interface { m(); M }
type U3 interface { M; m() }
type U4 interface { M; M; M }
type U5 interface { U1; U2; U3; U4 }

type U6 interface { m(); m() } // ERROR "duplicate method .*m"
type U7 interface { M32; m() } // ERROR "duplicate method .*m"