)

type Blog struct {
	ID         uint   `gorm:"primary_key"`
	Locale     string `gorm:"primary_key"`
	Subject    string
	Body       string
	Tags       []Tag `gorm:"many2many:blog_tags;"`
	SharedTags []Tag `gorm:"many2many:shared_blog_tags;ForeignKey:id;References:id"`
	LocaleTags []Tag `gorm:"many2many:locale_blog_tags;ForeignKey:id,locale;References:id"`
}

type Tag struct {
	ID     uint   `gorm:"primary_key"`

type Eq struct {
	Column interface{}
	Value  interface{}
}

func (eq Eq) Build(builder Builder) {
	builder.WriteQuoted(eq.Column)

	switch eq.Value.(type) {
	case []string, []int, []int32, []int64, []uint, []uint32, []uint64, []interface{}:
		rv := reflect.ValueOf(eq.Value)
		if rv.Len() == 0 {
			builder.WriteString(" IN (NULL)")
		} else {
			builder.WriteString(" IN (")

	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

type Person struct {
	ID        int
	Name      string
	Addresses []Address `gorm:"many2many:person_addresses;"`
	DeletedAt gorm.DeletedAt
}

type Address struct {
	ID   uint
	Name string
}

type PersonAddress struct {
	PersonID  int
	AddressID int
	CreatedAt time.Time
	DeletedAt gorm.DeletedAt
}

func TestOverrideJoinTable(t *testing.T) {

	if b {
		*t |= other
	}
}

// Mask returns the mask as a uint64.
func (t Mask) Mask() uint64 {
	return uint64(t)
}

// Maskable implementations must return their mask as a 64 bit uint.
type Maskable interface {
	Mask() uint64

// that the first byte can only be either 0x80 or 0xff. Thus, the first byte is
// equivalent to the sign bit in two's complement form.
func fitsInBase256(n int, x int64) bool {
	binBits := uint(n-1) * 8
	return n >= 9 || (x >= -1<<binBits && x < 1<<binBits)
}

// parseNumeric parses the input as being encoded in either base-256 or octal.
// This function may return negative numbers.

package jstream

import (
	"io"
	"sync/atomic"
)

const (
	chunk    = 4095 // ~4k
	maxUint  = ^uint(0)
	maxInt   = int64(maxUint >> 1)
	nullByte = byte(0)
)

type scanner struct {
	pos       int64 // position in reader
	ipos      int64 // internal buffer position
	ifill     int64 // internal buffer fill
	end       int64
	buf       [chunk + 1]byte // internal buffer (with a lookback size of 1)

	tidbSkip(t, "not support the foreign key feature")

	type City struct {
		gorm.Model
		Name string `gorm:"unique"`
	}

	type Museum struct {
		gorm.Model
		Name   string `gorm:"unique"`
		CityID uint
		City   City `gorm:"Constraint:OnUpdate:CASCADE,OnDelete:CASCADE;FOREIGNKEY:CityID;References:ID"`
	}

	db, err := OpenTestConnection(&gorm.Config{TranslateError: true})
	if err != nil {

pkg image, method (Rectangle) Bounds() Rectangle
pkg image, method (Rectangle) ColorModel() color.Model
pkg image, type CMYK struct
pkg image, type CMYK struct, Pix []uint8
pkg image, type CMYK struct, Rect Rectangle
pkg image, type CMYK struct, Stride int
pkg image/color, func CMYKToRGB(uint8, uint8, uint8, uint8) (uint8, uint8, uint8)

func (z *Int) Mod(x, y *Int) *Int {
	x.doinit()
	y.doinit()
	z.doinit()
	C.mpz_tdiv_r(&z.i[0], &x.i[0], &y.i[0])
	return z
}

// Lsh sets z = x << s and returns z.
func (z *Int) Lsh(x *Int, s uint) *Int {
	x.doinit()
	z.doinit()
	C._mpz_mul_2exp(&z.i[0], &x.i[0], C.ulong(s))
	return z
}

// Rsh sets z = x >> s and returns z.
func (z *Int) Rsh(x *Int, s uint) *Int {
	x.doinit()

var t0, t1, t2, t3 uint32 for r := 0; r < c.rounds-1; r++ { t0 = xk[k+0] ^ te0[uint8(s0>>24)] ^ te1[uint8(s1>>16)] ^ te2[uint8(s2>>8)] ^ te3[uint8(s3)] t1 = xk[k+1] ^ te0[uint8(s1>>24)] ^ te1[uint8(s2>>16)] ^ te2[uint8(s3>>8)] ^ te3[uint8(s0)] t2 = xk[k+2] ^ te0[uint8(s2>>24)] ^ te1[uint8(s3>>16)] ^ te2[uint8(s0>>8)] ^ te3[uint8(s1)] t3 = xk[k+3] ^ te0[uint8(s3>>24)] ^ te1[uint8(s0>>16)] ^ te2[uint8(s1>>8)] ^ te3[uint8(s2)] k += 4 s0, s1, s2, s3 = t0, t1, t2, t3 } // Last round uses s-box directly...