csgowtfd/ent/stats/where.go

// Code generated by entc, DO NOT EDIT.

package stats

import (
	"csgowtfd/ent/predicate"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
)

// ID filters vertices based on their ID field.
func ID(id int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDEQ applies the EQ predicate on the ID field.
func IDEQ(id int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDNEQ applies the NEQ predicate on the ID field.
func IDNEQ(id int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldID), id))
	})
}

// IDIn applies the In predicate on the ID field.
func IDIn(ids ...int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(ids) == 0 {
			s.Where(sql.False())
			return
		}
		v := make([]interface{}, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.In(s.C(FieldID), v...))
	})
}

// IDNotIn applies the NotIn predicate on the ID field.
func IDNotIn(ids ...int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(ids) == 0 {
			s.Where(sql.False())
			return
		}
		v := make([]interface{}, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.NotIn(s.C(FieldID), v...))
	})
}

// IDGT applies the GT predicate on the ID field.
func IDGT(id int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldID), id))
	})
}

// IDGTE applies the GTE predicate on the ID field.
func IDGTE(id int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldID), id))
	})
}

// IDLT applies the LT predicate on the ID field.
func IDLT(id int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldID), id))
	})
}

// IDLTE applies the LTE predicate on the ID field.
func IDLTE(id int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldID), id))
	})
}

// TeamID applies equality check predicate on the "team_id" field. It's identical to TeamIDEQ.
func TeamID(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTeamID), v))
	})
}

// Kills applies equality check predicate on the "kills" field. It's identical to KillsEQ.
func Kills(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldKills), v))
	})
}

// Deaths applies equality check predicate on the "deaths" field. It's identical to DeathsEQ.
func Deaths(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldDeaths), v))
	})
}

// Assists applies equality check predicate on the "assists" field. It's identical to AssistsEQ.
func Assists(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAssists), v))
	})
}

// Headshot applies equality check predicate on the "headshot" field. It's identical to HeadshotEQ.
func Headshot(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHeadshot), v))
	})
}

// Mvp applies equality check predicate on the "mvp" field. It's identical to MvpEQ.
func Mvp(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMvp), v))
	})
}

// Score applies equality check predicate on the "score" field. It's identical to ScoreEQ.
func Score(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldScore), v))
	})
}

// RankNew applies equality check predicate on the "rank_new" field. It's identical to RankNewEQ.
func RankNew(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldRankNew), v))
	})
}

// RankOld applies equality check predicate on the "rank_old" field. It's identical to RankOldEQ.
func RankOld(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldRankOld), v))
	})
}

// Mk2 applies equality check predicate on the "mk_2" field. It's identical to Mk2EQ.
func Mk2(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMk2), v))
	})
}

// Mk3 applies equality check predicate on the "mk_3" field. It's identical to Mk3EQ.
func Mk3(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMk3), v))
	})
}

// Mk4 applies equality check predicate on the "mk_4" field. It's identical to Mk4EQ.
func Mk4(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMk4), v))
	})
}

// Mk5 applies equality check predicate on the "mk_5" field. It's identical to Mk5EQ.
func Mk5(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMk5), v))
	})
}

// DmgEnemy applies equality check predicate on the "dmg_enemy" field. It's identical to DmgEnemyEQ.
func DmgEnemy(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldDmgEnemy), v))
	})
}

// DmgTeam applies equality check predicate on the "dmg_team" field. It's identical to DmgTeamEQ.
func DmgTeam(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldDmgTeam), v))
	})
}

// UdHe applies equality check predicate on the "ud_he" field. It's identical to UdHeEQ.
func UdHe(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdHe), v))
	})
}

// UdFlames applies equality check predicate on the "ud_flames" field. It's identical to UdFlamesEQ.
func UdFlames(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdFlames), v))
	})
}

// UdFlash applies equality check predicate on the "ud_flash" field. It's identical to UdFlashEQ.
func UdFlash(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdFlash), v))
	})
}

// UdDecoy applies equality check predicate on the "ud_decoy" field. It's identical to UdDecoyEQ.
func UdDecoy(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdDecoy), v))
	})
}

// UdSmoke applies equality check predicate on the "ud_smoke" field. It's identical to UdSmokeEQ.
func UdSmoke(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdSmoke), v))
	})
}

// HitGroupHead applies equality check predicate on the "hit_group_head" field. It's identical to HitGroupHeadEQ.
func HitGroupHead(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupHead), v))
	})
}

// HitGroupChest applies equality check predicate on the "hit_group_chest" field. It's identical to HitGroupChestEQ.
func HitGroupChest(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupChest), v))
	})
}

// HitGroupStomach applies equality check predicate on the "hit_group_stomach" field. It's identical to HitGroupStomachEQ.
func HitGroupStomach(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupStomach), v))
	})
}

// HitGroupLeftArm applies equality check predicate on the "hit_group_left_arm" field. It's identical to HitGroupLeftArmEQ.
func HitGroupLeftArm(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupLeftArm), v))
	})
}

// HitGroupRightArm applies equality check predicate on the "hit_group_right_arm" field. It's identical to HitGroupRightArmEQ.
func HitGroupRightArm(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupRightArm), v))
	})
}

// HitGroupLeftLeg applies equality check predicate on the "hit_group_left_leg" field. It's identical to HitGroupLeftLegEQ.
func HitGroupLeftLeg(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupLeftLeg), v))
	})
}

// HitGroupRightLeg applies equality check predicate on the "hit_group_right_leg" field. It's identical to HitGroupRightLegEQ.
func HitGroupRightLeg(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupRightLeg), v))
	})
}

// HitGroupGear applies equality check predicate on the "hit_group_gear" field. It's identical to HitGroupGearEQ.
func HitGroupGear(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupGear), v))
	})
}

// Crosshair applies equality check predicate on the "crosshair" field. It's identical to CrosshairEQ.
func Crosshair(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldCrosshair), v))
	})
}

// Kast applies equality check predicate on the "kast" field. It's identical to KastEQ.
func Kast(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldKast), v))
	})
}

// FlashDurationSelf applies equality check predicate on the "flash_duration_self" field. It's identical to FlashDurationSelfEQ.
func FlashDurationSelf(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashDurationSelf), v))
	})
}

// FlashDurationTeam applies equality check predicate on the "flash_duration_team" field. It's identical to FlashDurationTeamEQ.
func FlashDurationTeam(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashDurationTeam), v))
	})
}

// FlashDurationEnemy applies equality check predicate on the "flash_duration_enemy" field. It's identical to FlashDurationEnemyEQ.
func FlashDurationEnemy(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashDurationEnemy), v))
	})
}

// FlashTotalSelf applies equality check predicate on the "flash_total_self" field. It's identical to FlashTotalSelfEQ.
func FlashTotalSelf(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashTotalSelf), v))
	})
}

// FlashTotalTeam applies equality check predicate on the "flash_total_team" field. It's identical to FlashTotalTeamEQ.
func FlashTotalTeam(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashTotalTeam), v))
	})
}

// FlashTotalEnemy applies equality check predicate on the "flash_total_enemy" field. It's identical to FlashTotalEnemyEQ.
func FlashTotalEnemy(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashTotalEnemy), v))
	})
}

// MatchStats applies equality check predicate on the "match_stats" field. It's identical to MatchStatsEQ.
func MatchStats(v uint64) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMatchStats), v))
	})
}

// PlayerStats applies equality check predicate on the "player_stats" field. It's identical to PlayerStatsEQ.
func PlayerStats(v uint64) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPlayerStats), v))
	})
}

// TeamIDEQ applies the EQ predicate on the "team_id" field.
func TeamIDEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTeamID), v))
	})
}

// TeamIDNEQ applies the NEQ predicate on the "team_id" field.
func TeamIDNEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldTeamID), v))
	})
}

// TeamIDIn applies the In predicate on the "team_id" field.
func TeamIDIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldTeamID), v...))
	})
}

// TeamIDNotIn applies the NotIn predicate on the "team_id" field.
func TeamIDNotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldTeamID), v...))
	})
}

// TeamIDGT applies the GT predicate on the "team_id" field.
func TeamIDGT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldTeamID), v))
	})
}

// TeamIDGTE applies the GTE predicate on the "team_id" field.
func TeamIDGTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldTeamID), v))
	})
}

// TeamIDLT applies the LT predicate on the "team_id" field.
func TeamIDLT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldTeamID), v))
	})
}

// TeamIDLTE applies the LTE predicate on the "team_id" field.
func TeamIDLTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldTeamID), v))
	})
}

// KillsEQ applies the EQ predicate on the "kills" field.
func KillsEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldKills), v))
	})
}

// KillsNEQ applies the NEQ predicate on the "kills" field.
func KillsNEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldKills), v))
	})
}

// KillsIn applies the In predicate on the "kills" field.
func KillsIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldKills), v...))
	})
}

// KillsNotIn applies the NotIn predicate on the "kills" field.
func KillsNotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldKills), v...))
	})
}

// KillsGT applies the GT predicate on the "kills" field.
func KillsGT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldKills), v))
	})
}

// KillsGTE applies the GTE predicate on the "kills" field.
func KillsGTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldKills), v))
	})
}

// KillsLT applies the LT predicate on the "kills" field.
func KillsLT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldKills), v))
	})
}

// KillsLTE applies the LTE predicate on the "kills" field.
func KillsLTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldKills), v))
	})
}

// DeathsEQ applies the EQ predicate on the "deaths" field.
func DeathsEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldDeaths), v))
	})
}

// DeathsNEQ applies the NEQ predicate on the "deaths" field.
func DeathsNEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldDeaths), v))
	})
}

// DeathsIn applies the In predicate on the "deaths" field.
func DeathsIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldDeaths), v...))
	})
}

// DeathsNotIn applies the NotIn predicate on the "deaths" field.
func DeathsNotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldDeaths), v...))
	})
}

// DeathsGT applies the GT predicate on the "deaths" field.
func DeathsGT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldDeaths), v))
	})
}

// DeathsGTE applies the GTE predicate on the "deaths" field.
func DeathsGTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldDeaths), v))
	})
}

// DeathsLT applies the LT predicate on the "deaths" field.
func DeathsLT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldDeaths), v))
	})
}

// DeathsLTE applies the LTE predicate on the "deaths" field.
func DeathsLTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldDeaths), v))
	})
}

// AssistsEQ applies the EQ predicate on the "assists" field.
func AssistsEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAssists), v))
	})
}

// AssistsNEQ applies the NEQ predicate on the "assists" field.
func AssistsNEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldAssists), v))
	})
}

// AssistsIn applies the In predicate on the "assists" field.
func AssistsIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldAssists), v...))
	})
}

// AssistsNotIn applies the NotIn predicate on the "assists" field.
func AssistsNotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldAssists), v...))
	})
}

// AssistsGT applies the GT predicate on the "assists" field.
func AssistsGT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldAssists), v))
	})
}

// AssistsGTE applies the GTE predicate on the "assists" field.
func AssistsGTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldAssists), v))
	})
}

// AssistsLT applies the LT predicate on the "assists" field.
func AssistsLT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldAssists), v))
	})
}

// AssistsLTE applies the LTE predicate on the "assists" field.
func AssistsLTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldAssists), v))
	})
}

// HeadshotEQ applies the EQ predicate on the "headshot" field.
func HeadshotEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHeadshot), v))
	})
}

// HeadshotNEQ applies the NEQ predicate on the "headshot" field.
func HeadshotNEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldHeadshot), v))
	})
}

// HeadshotIn applies the In predicate on the "headshot" field.
func HeadshotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldHeadshot), v...))
	})
}

// HeadshotNotIn applies the NotIn predicate on the "headshot" field.
func HeadshotNotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldHeadshot), v...))
	})
}

// HeadshotGT applies the GT predicate on the "headshot" field.
func HeadshotGT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldHeadshot), v))
	})
}

// HeadshotGTE applies the GTE predicate on the "headshot" field.
func HeadshotGTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldHeadshot), v))
	})
}

// HeadshotLT applies the LT predicate on the "headshot" field.
func HeadshotLT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldHeadshot), v))
	})
}

// HeadshotLTE applies the LTE predicate on the "headshot" field.
func HeadshotLTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldHeadshot), v))
	})
}

// MvpEQ applies the EQ predicate on the "mvp" field.
func MvpEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMvp), v))
	})
}

// MvpNEQ applies the NEQ predicate on the "mvp" field.
func MvpNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldMvp), v))
	})
}

// MvpIn applies the In predicate on the "mvp" field.
func MvpIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldMvp), v...))
	})
}

// MvpNotIn applies the NotIn predicate on the "mvp" field.
func MvpNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldMvp), v...))
	})
}

// MvpGT applies the GT predicate on the "mvp" field.
func MvpGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldMvp), v))
	})
}

// MvpGTE applies the GTE predicate on the "mvp" field.
func MvpGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldMvp), v))
	})
}

// MvpLT applies the LT predicate on the "mvp" field.
func MvpLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldMvp), v))
	})
}

// MvpLTE applies the LTE predicate on the "mvp" field.
func MvpLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldMvp), v))
	})
}

// ScoreEQ applies the EQ predicate on the "score" field.
func ScoreEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldScore), v))
	})
}

// ScoreNEQ applies the NEQ predicate on the "score" field.
func ScoreNEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldScore), v))
	})
}

// ScoreIn applies the In predicate on the "score" field.
func ScoreIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldScore), v...))
	})
}

// ScoreNotIn applies the NotIn predicate on the "score" field.
func ScoreNotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldScore), v...))
	})
}

// ScoreGT applies the GT predicate on the "score" field.
func ScoreGT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldScore), v))
	})
}

// ScoreGTE applies the GTE predicate on the "score" field.
func ScoreGTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldScore), v))
	})
}

// ScoreLT applies the LT predicate on the "score" field.
func ScoreLT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldScore), v))
	})
}

// ScoreLTE applies the LTE predicate on the "score" field.
func ScoreLTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldScore), v))
	})
}

// RankNewEQ applies the EQ predicate on the "rank_new" field.
func RankNewEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldRankNew), v))
	})
}

// RankNewNEQ applies the NEQ predicate on the "rank_new" field.
func RankNewNEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldRankNew), v))
	})
}

// RankNewIn applies the In predicate on the "rank_new" field.
func RankNewIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldRankNew), v...))
	})
}

// RankNewNotIn applies the NotIn predicate on the "rank_new" field.
func RankNewNotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldRankNew), v...))
	})
}

// RankNewGT applies the GT predicate on the "rank_new" field.
func RankNewGT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldRankNew), v))
	})
}

// RankNewGTE applies the GTE predicate on the "rank_new" field.
func RankNewGTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldRankNew), v))
	})
}

// RankNewLT applies the LT predicate on the "rank_new" field.
func RankNewLT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldRankNew), v))
	})
}

// RankNewLTE applies the LTE predicate on the "rank_new" field.
func RankNewLTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldRankNew), v))
	})
}

// RankNewIsNil applies the IsNil predicate on the "rank_new" field.
func RankNewIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldRankNew)))
	})
}

// RankNewNotNil applies the NotNil predicate on the "rank_new" field.
func RankNewNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldRankNew)))
	})
}

// RankOldEQ applies the EQ predicate on the "rank_old" field.
func RankOldEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldRankOld), v))
	})
}

// RankOldNEQ applies the NEQ predicate on the "rank_old" field.
func RankOldNEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldRankOld), v))
	})
}

// RankOldIn applies the In predicate on the "rank_old" field.
func RankOldIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldRankOld), v...))
	})
}

// RankOldNotIn applies the NotIn predicate on the "rank_old" field.
func RankOldNotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldRankOld), v...))
	})
}

// RankOldGT applies the GT predicate on the "rank_old" field.
func RankOldGT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldRankOld), v))
	})
}

// RankOldGTE applies the GTE predicate on the "rank_old" field.
func RankOldGTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldRankOld), v))
	})
}

// RankOldLT applies the LT predicate on the "rank_old" field.
func RankOldLT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldRankOld), v))
	})
}

// RankOldLTE applies the LTE predicate on the "rank_old" field.
func RankOldLTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldRankOld), v))
	})
}

// RankOldIsNil applies the IsNil predicate on the "rank_old" field.
func RankOldIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldRankOld)))
	})
}

// RankOldNotNil applies the NotNil predicate on the "rank_old" field.
func RankOldNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldRankOld)))
	})
}

// Mk2EQ applies the EQ predicate on the "mk_2" field.
func Mk2EQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMk2), v))
	})
}

// Mk2NEQ applies the NEQ predicate on the "mk_2" field.
func Mk2NEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldMk2), v))
	})
}

// Mk2In applies the In predicate on the "mk_2" field.
func Mk2In(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldMk2), v...))
	})
}

// Mk2NotIn applies the NotIn predicate on the "mk_2" field.
func Mk2NotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldMk2), v...))
	})
}

// Mk2GT applies the GT predicate on the "mk_2" field.
func Mk2GT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldMk2), v))
	})
}

// Mk2GTE applies the GTE predicate on the "mk_2" field.
func Mk2GTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldMk2), v))
	})
}

// Mk2LT applies the LT predicate on the "mk_2" field.
func Mk2LT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldMk2), v))
	})
}

// Mk2LTE applies the LTE predicate on the "mk_2" field.
func Mk2LTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldMk2), v))
	})
}

// Mk2IsNil applies the IsNil predicate on the "mk_2" field.
func Mk2IsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldMk2)))
	})
}

// Mk2NotNil applies the NotNil predicate on the "mk_2" field.
func Mk2NotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldMk2)))
	})
}

// Mk3EQ applies the EQ predicate on the "mk_3" field.
func Mk3EQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMk3), v))
	})
}

// Mk3NEQ applies the NEQ predicate on the "mk_3" field.
func Mk3NEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldMk3), v))
	})
}

// Mk3In applies the In predicate on the "mk_3" field.
func Mk3In(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldMk3), v...))
	})
}

// Mk3NotIn applies the NotIn predicate on the "mk_3" field.
func Mk3NotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldMk3), v...))
	})
}

// Mk3GT applies the GT predicate on the "mk_3" field.
func Mk3GT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldMk3), v))
	})
}

// Mk3GTE applies the GTE predicate on the "mk_3" field.
func Mk3GTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldMk3), v))
	})
}

// Mk3LT applies the LT predicate on the "mk_3" field.
func Mk3LT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldMk3), v))
	})
}

// Mk3LTE applies the LTE predicate on the "mk_3" field.
func Mk3LTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldMk3), v))
	})
}

// Mk3IsNil applies the IsNil predicate on the "mk_3" field.
func Mk3IsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldMk3)))
	})
}

// Mk3NotNil applies the NotNil predicate on the "mk_3" field.
func Mk3NotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldMk3)))
	})
}

// Mk4EQ applies the EQ predicate on the "mk_4" field.
func Mk4EQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMk4), v))
	})
}

// Mk4NEQ applies the NEQ predicate on the "mk_4" field.
func Mk4NEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldMk4), v))
	})
}

// Mk4In applies the In predicate on the "mk_4" field.
func Mk4In(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldMk4), v...))
	})
}

// Mk4NotIn applies the NotIn predicate on the "mk_4" field.
func Mk4NotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldMk4), v...))
	})
}

// Mk4GT applies the GT predicate on the "mk_4" field.
func Mk4GT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldMk4), v))
	})
}

// Mk4GTE applies the GTE predicate on the "mk_4" field.
func Mk4GTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldMk4), v))
	})
}

// Mk4LT applies the LT predicate on the "mk_4" field.
func Mk4LT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldMk4), v))
	})
}

// Mk4LTE applies the LTE predicate on the "mk_4" field.
func Mk4LTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldMk4), v))
	})
}

// Mk4IsNil applies the IsNil predicate on the "mk_4" field.
func Mk4IsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldMk4)))
	})
}

// Mk4NotNil applies the NotNil predicate on the "mk_4" field.
func Mk4NotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldMk4)))
	})
}

// Mk5EQ applies the EQ predicate on the "mk_5" field.
func Mk5EQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMk5), v))
	})
}

// Mk5NEQ applies the NEQ predicate on the "mk_5" field.
func Mk5NEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldMk5), v))
	})
}

// Mk5In applies the In predicate on the "mk_5" field.
func Mk5In(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldMk5), v...))
	})
}

// Mk5NotIn applies the NotIn predicate on the "mk_5" field.
func Mk5NotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldMk5), v...))
	})
}

// Mk5GT applies the GT predicate on the "mk_5" field.
func Mk5GT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldMk5), v))
	})
}

// Mk5GTE applies the GTE predicate on the "mk_5" field.
func Mk5GTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldMk5), v))
	})
}

// Mk5LT applies the LT predicate on the "mk_5" field.
func Mk5LT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldMk5), v))
	})
}

// Mk5LTE applies the LTE predicate on the "mk_5" field.
func Mk5LTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldMk5), v))
	})
}

// Mk5IsNil applies the IsNil predicate on the "mk_5" field.
func Mk5IsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldMk5)))
	})
}

// Mk5NotNil applies the NotNil predicate on the "mk_5" field.
func Mk5NotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldMk5)))
	})
}

// DmgEnemyEQ applies the EQ predicate on the "dmg_enemy" field.
func DmgEnemyEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldDmgEnemy), v))
	})
}

// DmgEnemyNEQ applies the NEQ predicate on the "dmg_enemy" field.
func DmgEnemyNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldDmgEnemy), v))
	})
}

// DmgEnemyIn applies the In predicate on the "dmg_enemy" field.
func DmgEnemyIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldDmgEnemy), v...))
	})
}

// DmgEnemyNotIn applies the NotIn predicate on the "dmg_enemy" field.
func DmgEnemyNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldDmgEnemy), v...))
	})
}

// DmgEnemyGT applies the GT predicate on the "dmg_enemy" field.
func DmgEnemyGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldDmgEnemy), v))
	})
}

// DmgEnemyGTE applies the GTE predicate on the "dmg_enemy" field.
func DmgEnemyGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldDmgEnemy), v))
	})
}

// DmgEnemyLT applies the LT predicate on the "dmg_enemy" field.
func DmgEnemyLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldDmgEnemy), v))
	})
}

// DmgEnemyLTE applies the LTE predicate on the "dmg_enemy" field.
func DmgEnemyLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldDmgEnemy), v))
	})
}

// DmgEnemyIsNil applies the IsNil predicate on the "dmg_enemy" field.
func DmgEnemyIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldDmgEnemy)))
	})
}

// DmgEnemyNotNil applies the NotNil predicate on the "dmg_enemy" field.
func DmgEnemyNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldDmgEnemy)))
	})
}

// DmgTeamEQ applies the EQ predicate on the "dmg_team" field.
func DmgTeamEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldDmgTeam), v))
	})
}

// DmgTeamNEQ applies the NEQ predicate on the "dmg_team" field.
func DmgTeamNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldDmgTeam), v))
	})
}

// DmgTeamIn applies the In predicate on the "dmg_team" field.
func DmgTeamIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldDmgTeam), v...))
	})
}

// DmgTeamNotIn applies the NotIn predicate on the "dmg_team" field.
func DmgTeamNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldDmgTeam), v...))
	})
}

// DmgTeamGT applies the GT predicate on the "dmg_team" field.
func DmgTeamGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldDmgTeam), v))
	})
}

// DmgTeamGTE applies the GTE predicate on the "dmg_team" field.
func DmgTeamGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldDmgTeam), v))
	})
}

// DmgTeamLT applies the LT predicate on the "dmg_team" field.
func DmgTeamLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldDmgTeam), v))
	})
}

// DmgTeamLTE applies the LTE predicate on the "dmg_team" field.
func DmgTeamLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldDmgTeam), v))
	})
}

// DmgTeamIsNil applies the IsNil predicate on the "dmg_team" field.
func DmgTeamIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldDmgTeam)))
	})
}

// DmgTeamNotNil applies the NotNil predicate on the "dmg_team" field.
func DmgTeamNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldDmgTeam)))
	})
}

// UdHeEQ applies the EQ predicate on the "ud_he" field.
func UdHeEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdHe), v))
	})
}

// UdHeNEQ applies the NEQ predicate on the "ud_he" field.
func UdHeNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldUdHe), v))
	})
}

// UdHeIn applies the In predicate on the "ud_he" field.
func UdHeIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldUdHe), v...))
	})
}

// UdHeNotIn applies the NotIn predicate on the "ud_he" field.
func UdHeNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldUdHe), v...))
	})
}

// UdHeGT applies the GT predicate on the "ud_he" field.
func UdHeGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldUdHe), v))
	})
}

// UdHeGTE applies the GTE predicate on the "ud_he" field.
func UdHeGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldUdHe), v))
	})
}

// UdHeLT applies the LT predicate on the "ud_he" field.
func UdHeLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldUdHe), v))
	})
}

// UdHeLTE applies the LTE predicate on the "ud_he" field.
func UdHeLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldUdHe), v))
	})
}

// UdHeIsNil applies the IsNil predicate on the "ud_he" field.
func UdHeIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldUdHe)))
	})
}

// UdHeNotNil applies the NotNil predicate on the "ud_he" field.
func UdHeNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldUdHe)))
	})
}

// UdFlamesEQ applies the EQ predicate on the "ud_flames" field.
func UdFlamesEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdFlames), v))
	})
}

// UdFlamesNEQ applies the NEQ predicate on the "ud_flames" field.
func UdFlamesNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldUdFlames), v))
	})
}

// UdFlamesIn applies the In predicate on the "ud_flames" field.
func UdFlamesIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldUdFlames), v...))
	})
}

// UdFlamesNotIn applies the NotIn predicate on the "ud_flames" field.
func UdFlamesNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldUdFlames), v...))
	})
}

// UdFlamesGT applies the GT predicate on the "ud_flames" field.
func UdFlamesGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldUdFlames), v))
	})
}

// UdFlamesGTE applies the GTE predicate on the "ud_flames" field.
func UdFlamesGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldUdFlames), v))
	})
}

// UdFlamesLT applies the LT predicate on the "ud_flames" field.
func UdFlamesLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldUdFlames), v))
	})
}

// UdFlamesLTE applies the LTE predicate on the "ud_flames" field.
func UdFlamesLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldUdFlames), v))
	})
}

// UdFlamesIsNil applies the IsNil predicate on the "ud_flames" field.
func UdFlamesIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldUdFlames)))
	})
}

// UdFlamesNotNil applies the NotNil predicate on the "ud_flames" field.
func UdFlamesNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldUdFlames)))
	})
}

// UdFlashEQ applies the EQ predicate on the "ud_flash" field.
func UdFlashEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdFlash), v))
	})
}

// UdFlashNEQ applies the NEQ predicate on the "ud_flash" field.
func UdFlashNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldUdFlash), v))
	})
}

// UdFlashIn applies the In predicate on the "ud_flash" field.
func UdFlashIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldUdFlash), v...))
	})
}

// UdFlashNotIn applies the NotIn predicate on the "ud_flash" field.
func UdFlashNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldUdFlash), v...))
	})
}

// UdFlashGT applies the GT predicate on the "ud_flash" field.
func UdFlashGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldUdFlash), v))
	})
}

// UdFlashGTE applies the GTE predicate on the "ud_flash" field.
func UdFlashGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldUdFlash), v))
	})
}

// UdFlashLT applies the LT predicate on the "ud_flash" field.
func UdFlashLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldUdFlash), v))
	})
}

// UdFlashLTE applies the LTE predicate on the "ud_flash" field.
func UdFlashLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldUdFlash), v))
	})
}

// UdFlashIsNil applies the IsNil predicate on the "ud_flash" field.
func UdFlashIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldUdFlash)))
	})
}

// UdFlashNotNil applies the NotNil predicate on the "ud_flash" field.
func UdFlashNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldUdFlash)))
	})
}

// UdDecoyEQ applies the EQ predicate on the "ud_decoy" field.
func UdDecoyEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdDecoy), v))
	})
}

// UdDecoyNEQ applies the NEQ predicate on the "ud_decoy" field.
func UdDecoyNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldUdDecoy), v))
	})
}

// UdDecoyIn applies the In predicate on the "ud_decoy" field.
func UdDecoyIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldUdDecoy), v...))
	})
}

// UdDecoyNotIn applies the NotIn predicate on the "ud_decoy" field.
func UdDecoyNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldUdDecoy), v...))
	})
}

// UdDecoyGT applies the GT predicate on the "ud_decoy" field.
func UdDecoyGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldUdDecoy), v))
	})
}

// UdDecoyGTE applies the GTE predicate on the "ud_decoy" field.
func UdDecoyGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldUdDecoy), v))
	})
}

// UdDecoyLT applies the LT predicate on the "ud_decoy" field.
func UdDecoyLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldUdDecoy), v))
	})
}

// UdDecoyLTE applies the LTE predicate on the "ud_decoy" field.
func UdDecoyLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldUdDecoy), v))
	})
}

// UdDecoyIsNil applies the IsNil predicate on the "ud_decoy" field.
func UdDecoyIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldUdDecoy)))
	})
}

// UdDecoyNotNil applies the NotNil predicate on the "ud_decoy" field.
func UdDecoyNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldUdDecoy)))
	})
}

// UdSmokeEQ applies the EQ predicate on the "ud_smoke" field.
func UdSmokeEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUdSmoke), v))
	})
}

// UdSmokeNEQ applies the NEQ predicate on the "ud_smoke" field.
func UdSmokeNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldUdSmoke), v))
	})
}

// UdSmokeIn applies the In predicate on the "ud_smoke" field.
func UdSmokeIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldUdSmoke), v...))
	})
}

// UdSmokeNotIn applies the NotIn predicate on the "ud_smoke" field.
func UdSmokeNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldUdSmoke), v...))
	})
}

// UdSmokeGT applies the GT predicate on the "ud_smoke" field.
func UdSmokeGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldUdSmoke), v))
	})
}

// UdSmokeGTE applies the GTE predicate on the "ud_smoke" field.
func UdSmokeGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldUdSmoke), v))
	})
}

// UdSmokeLT applies the LT predicate on the "ud_smoke" field.
func UdSmokeLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldUdSmoke), v))
	})
}

// UdSmokeLTE applies the LTE predicate on the "ud_smoke" field.
func UdSmokeLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldUdSmoke), v))
	})
}

// UdSmokeIsNil applies the IsNil predicate on the "ud_smoke" field.
func UdSmokeIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldUdSmoke)))
	})
}

// UdSmokeNotNil applies the NotNil predicate on the "ud_smoke" field.
func UdSmokeNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldUdSmoke)))
	})
}

// HitGroupHeadEQ applies the EQ predicate on the "hit_group_head" field.
func HitGroupHeadEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupHead), v))
	})
}

// HitGroupHeadNEQ applies the NEQ predicate on the "hit_group_head" field.
func HitGroupHeadNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldHitGroupHead), v))
	})
}

// HitGroupHeadIn applies the In predicate on the "hit_group_head" field.
func HitGroupHeadIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldHitGroupHead), v...))
	})
}

// HitGroupHeadNotIn applies the NotIn predicate on the "hit_group_head" field.
func HitGroupHeadNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldHitGroupHead), v...))
	})
}

// HitGroupHeadGT applies the GT predicate on the "hit_group_head" field.
func HitGroupHeadGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldHitGroupHead), v))
	})
}

// HitGroupHeadGTE applies the GTE predicate on the "hit_group_head" field.
func HitGroupHeadGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldHitGroupHead), v))
	})
}

// HitGroupHeadLT applies the LT predicate on the "hit_group_head" field.
func HitGroupHeadLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldHitGroupHead), v))
	})
}

// HitGroupHeadLTE applies the LTE predicate on the "hit_group_head" field.
func HitGroupHeadLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldHitGroupHead), v))
	})
}

// HitGroupHeadIsNil applies the IsNil predicate on the "hit_group_head" field.
func HitGroupHeadIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldHitGroupHead)))
	})
}

// HitGroupHeadNotNil applies the NotNil predicate on the "hit_group_head" field.
func HitGroupHeadNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldHitGroupHead)))
	})
}

// HitGroupChestEQ applies the EQ predicate on the "hit_group_chest" field.
func HitGroupChestEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupChest), v))
	})
}

// HitGroupChestNEQ applies the NEQ predicate on the "hit_group_chest" field.
func HitGroupChestNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldHitGroupChest), v))
	})
}

// HitGroupChestIn applies the In predicate on the "hit_group_chest" field.
func HitGroupChestIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldHitGroupChest), v...))
	})
}

// HitGroupChestNotIn applies the NotIn predicate on the "hit_group_chest" field.
func HitGroupChestNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldHitGroupChest), v...))
	})
}

// HitGroupChestGT applies the GT predicate on the "hit_group_chest" field.
func HitGroupChestGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldHitGroupChest), v))
	})
}

// HitGroupChestGTE applies the GTE predicate on the "hit_group_chest" field.
func HitGroupChestGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldHitGroupChest), v))
	})
}

// HitGroupChestLT applies the LT predicate on the "hit_group_chest" field.
func HitGroupChestLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldHitGroupChest), v))
	})
}

// HitGroupChestLTE applies the LTE predicate on the "hit_group_chest" field.
func HitGroupChestLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldHitGroupChest), v))
	})
}

// HitGroupChestIsNil applies the IsNil predicate on the "hit_group_chest" field.
func HitGroupChestIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldHitGroupChest)))
	})
}

// HitGroupChestNotNil applies the NotNil predicate on the "hit_group_chest" field.
func HitGroupChestNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldHitGroupChest)))
	})
}

// HitGroupStomachEQ applies the EQ predicate on the "hit_group_stomach" field.
func HitGroupStomachEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupStomach), v))
	})
}

// HitGroupStomachNEQ applies the NEQ predicate on the "hit_group_stomach" field.
func HitGroupStomachNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldHitGroupStomach), v))
	})
}

// HitGroupStomachIn applies the In predicate on the "hit_group_stomach" field.
func HitGroupStomachIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldHitGroupStomach), v...))
	})
}

// HitGroupStomachNotIn applies the NotIn predicate on the "hit_group_stomach" field.
func HitGroupStomachNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldHitGroupStomach), v...))
	})
}

// HitGroupStomachGT applies the GT predicate on the "hit_group_stomach" field.
func HitGroupStomachGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldHitGroupStomach), v))
	})
}

// HitGroupStomachGTE applies the GTE predicate on the "hit_group_stomach" field.
func HitGroupStomachGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldHitGroupStomach), v))
	})
}

// HitGroupStomachLT applies the LT predicate on the "hit_group_stomach" field.
func HitGroupStomachLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldHitGroupStomach), v))
	})
}

// HitGroupStomachLTE applies the LTE predicate on the "hit_group_stomach" field.
func HitGroupStomachLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldHitGroupStomach), v))
	})
}

// HitGroupStomachIsNil applies the IsNil predicate on the "hit_group_stomach" field.
func HitGroupStomachIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldHitGroupStomach)))
	})
}

// HitGroupStomachNotNil applies the NotNil predicate on the "hit_group_stomach" field.
func HitGroupStomachNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldHitGroupStomach)))
	})
}

// HitGroupLeftArmEQ applies the EQ predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupLeftArm), v))
	})
}

// HitGroupLeftArmNEQ applies the NEQ predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldHitGroupLeftArm), v))
	})
}

// HitGroupLeftArmIn applies the In predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldHitGroupLeftArm), v...))
	})
}

// HitGroupLeftArmNotIn applies the NotIn predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldHitGroupLeftArm), v...))
	})
}

// HitGroupLeftArmGT applies the GT predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldHitGroupLeftArm), v))
	})
}

// HitGroupLeftArmGTE applies the GTE predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldHitGroupLeftArm), v))
	})
}

// HitGroupLeftArmLT applies the LT predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldHitGroupLeftArm), v))
	})
}

// HitGroupLeftArmLTE applies the LTE predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldHitGroupLeftArm), v))
	})
}

// HitGroupLeftArmIsNil applies the IsNil predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldHitGroupLeftArm)))
	})
}

// HitGroupLeftArmNotNil applies the NotNil predicate on the "hit_group_left_arm" field.
func HitGroupLeftArmNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldHitGroupLeftArm)))
	})
}

// HitGroupRightArmEQ applies the EQ predicate on the "hit_group_right_arm" field.
func HitGroupRightArmEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupRightArm), v))
	})
}

// HitGroupRightArmNEQ applies the NEQ predicate on the "hit_group_right_arm" field.
func HitGroupRightArmNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldHitGroupRightArm), v))
	})
}

// HitGroupRightArmIn applies the In predicate on the "hit_group_right_arm" field.
func HitGroupRightArmIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldHitGroupRightArm), v...))
	})
}

// HitGroupRightArmNotIn applies the NotIn predicate on the "hit_group_right_arm" field.
func HitGroupRightArmNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldHitGroupRightArm), v...))
	})
}

// HitGroupRightArmGT applies the GT predicate on the "hit_group_right_arm" field.
func HitGroupRightArmGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldHitGroupRightArm), v))
	})
}

// HitGroupRightArmGTE applies the GTE predicate on the "hit_group_right_arm" field.
func HitGroupRightArmGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldHitGroupRightArm), v))
	})
}

// HitGroupRightArmLT applies the LT predicate on the "hit_group_right_arm" field.
func HitGroupRightArmLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldHitGroupRightArm), v))
	})
}

// HitGroupRightArmLTE applies the LTE predicate on the "hit_group_right_arm" field.
func HitGroupRightArmLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldHitGroupRightArm), v))
	})
}

// HitGroupRightArmIsNil applies the IsNil predicate on the "hit_group_right_arm" field.
func HitGroupRightArmIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldHitGroupRightArm)))
	})
}

// HitGroupRightArmNotNil applies the NotNil predicate on the "hit_group_right_arm" field.
func HitGroupRightArmNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldHitGroupRightArm)))
	})
}

// HitGroupLeftLegEQ applies the EQ predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupLeftLeg), v))
	})
}

// HitGroupLeftLegNEQ applies the NEQ predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldHitGroupLeftLeg), v))
	})
}

// HitGroupLeftLegIn applies the In predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldHitGroupLeftLeg), v...))
	})
}

// HitGroupLeftLegNotIn applies the NotIn predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldHitGroupLeftLeg), v...))
	})
}

// HitGroupLeftLegGT applies the GT predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldHitGroupLeftLeg), v))
	})
}

// HitGroupLeftLegGTE applies the GTE predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldHitGroupLeftLeg), v))
	})
}

// HitGroupLeftLegLT applies the LT predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldHitGroupLeftLeg), v))
	})
}

// HitGroupLeftLegLTE applies the LTE predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldHitGroupLeftLeg), v))
	})
}

// HitGroupLeftLegIsNil applies the IsNil predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldHitGroupLeftLeg)))
	})
}

// HitGroupLeftLegNotNil applies the NotNil predicate on the "hit_group_left_leg" field.
func HitGroupLeftLegNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldHitGroupLeftLeg)))
	})
}

// HitGroupRightLegEQ applies the EQ predicate on the "hit_group_right_leg" field.
func HitGroupRightLegEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupRightLeg), v))
	})
}

// HitGroupRightLegNEQ applies the NEQ predicate on the "hit_group_right_leg" field.
func HitGroupRightLegNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldHitGroupRightLeg), v))
	})
}

// HitGroupRightLegIn applies the In predicate on the "hit_group_right_leg" field.
func HitGroupRightLegIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldHitGroupRightLeg), v...))
	})
}

// HitGroupRightLegNotIn applies the NotIn predicate on the "hit_group_right_leg" field.
func HitGroupRightLegNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldHitGroupRightLeg), v...))
	})
}

// HitGroupRightLegGT applies the GT predicate on the "hit_group_right_leg" field.
func HitGroupRightLegGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldHitGroupRightLeg), v))
	})
}

// HitGroupRightLegGTE applies the GTE predicate on the "hit_group_right_leg" field.
func HitGroupRightLegGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldHitGroupRightLeg), v))
	})
}

// HitGroupRightLegLT applies the LT predicate on the "hit_group_right_leg" field.
func HitGroupRightLegLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldHitGroupRightLeg), v))
	})
}

// HitGroupRightLegLTE applies the LTE predicate on the "hit_group_right_leg" field.
func HitGroupRightLegLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldHitGroupRightLeg), v))
	})
}

// HitGroupRightLegIsNil applies the IsNil predicate on the "hit_group_right_leg" field.
func HitGroupRightLegIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldHitGroupRightLeg)))
	})
}

// HitGroupRightLegNotNil applies the NotNil predicate on the "hit_group_right_leg" field.
func HitGroupRightLegNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldHitGroupRightLeg)))
	})
}

// HitGroupGearEQ applies the EQ predicate on the "hit_group_gear" field.
func HitGroupGearEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldHitGroupGear), v))
	})
}

// HitGroupGearNEQ applies the NEQ predicate on the "hit_group_gear" field.
func HitGroupGearNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldHitGroupGear), v))
	})
}

// HitGroupGearIn applies the In predicate on the "hit_group_gear" field.
func HitGroupGearIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldHitGroupGear), v...))
	})
}

// HitGroupGearNotIn applies the NotIn predicate on the "hit_group_gear" field.
func HitGroupGearNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldHitGroupGear), v...))
	})
}

// HitGroupGearGT applies the GT predicate on the "hit_group_gear" field.
func HitGroupGearGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldHitGroupGear), v))
	})
}

// HitGroupGearGTE applies the GTE predicate on the "hit_group_gear" field.
func HitGroupGearGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldHitGroupGear), v))
	})
}

// HitGroupGearLT applies the LT predicate on the "hit_group_gear" field.
func HitGroupGearLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldHitGroupGear), v))
	})
}

// HitGroupGearLTE applies the LTE predicate on the "hit_group_gear" field.
func HitGroupGearLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldHitGroupGear), v))
	})
}

// HitGroupGearIsNil applies the IsNil predicate on the "hit_group_gear" field.
func HitGroupGearIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldHitGroupGear)))
	})
}

// HitGroupGearNotNil applies the NotNil predicate on the "hit_group_gear" field.
func HitGroupGearNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldHitGroupGear)))
	})
}

// CrosshairEQ applies the EQ predicate on the "crosshair" field.
func CrosshairEQ(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldCrosshair), v))
	})
}

// CrosshairNEQ applies the NEQ predicate on the "crosshair" field.
func CrosshairNEQ(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldCrosshair), v))
	})
}

// CrosshairIn applies the In predicate on the "crosshair" field.
func CrosshairIn(vs ...string) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldCrosshair), v...))
	})
}

// CrosshairNotIn applies the NotIn predicate on the "crosshair" field.
func CrosshairNotIn(vs ...string) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldCrosshair), v...))
	})
}

// CrosshairGT applies the GT predicate on the "crosshair" field.
func CrosshairGT(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldCrosshair), v))
	})
}

// CrosshairGTE applies the GTE predicate on the "crosshair" field.
func CrosshairGTE(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldCrosshair), v))
	})
}

// CrosshairLT applies the LT predicate on the "crosshair" field.
func CrosshairLT(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldCrosshair), v))
	})
}

// CrosshairLTE applies the LTE predicate on the "crosshair" field.
func CrosshairLTE(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldCrosshair), v))
	})
}

// CrosshairContains applies the Contains predicate on the "crosshair" field.
func CrosshairContains(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldCrosshair), v))
	})
}

// CrosshairHasPrefix applies the HasPrefix predicate on the "crosshair" field.
func CrosshairHasPrefix(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldCrosshair), v))
	})
}

// CrosshairHasSuffix applies the HasSuffix predicate on the "crosshair" field.
func CrosshairHasSuffix(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldCrosshair), v))
	})
}

// CrosshairIsNil applies the IsNil predicate on the "crosshair" field.
func CrosshairIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldCrosshair)))
	})
}

// CrosshairNotNil applies the NotNil predicate on the "crosshair" field.
func CrosshairNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldCrosshair)))
	})
}

// CrosshairEqualFold applies the EqualFold predicate on the "crosshair" field.
func CrosshairEqualFold(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldCrosshair), v))
	})
}

// CrosshairContainsFold applies the ContainsFold predicate on the "crosshair" field.
func CrosshairContainsFold(v string) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldCrosshair), v))
	})
}

// ColorEQ applies the EQ predicate on the "color" field.
func ColorEQ(v Color) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldColor), v))
	})
}

// ColorNEQ applies the NEQ predicate on the "color" field.
func ColorNEQ(v Color) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldColor), v))
	})
}

// ColorIn applies the In predicate on the "color" field.
func ColorIn(vs ...Color) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldColor), v...))
	})
}

// ColorNotIn applies the NotIn predicate on the "color" field.
func ColorNotIn(vs ...Color) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldColor), v...))
	})
}

// ColorIsNil applies the IsNil predicate on the "color" field.
func ColorIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldColor)))
	})
}

// ColorNotNil applies the NotNil predicate on the "color" field.
func ColorNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldColor)))
	})
}

// KastEQ applies the EQ predicate on the "kast" field.
func KastEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldKast), v))
	})
}

// KastNEQ applies the NEQ predicate on the "kast" field.
func KastNEQ(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldKast), v))
	})
}

// KastIn applies the In predicate on the "kast" field.
func KastIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldKast), v...))
	})
}

// KastNotIn applies the NotIn predicate on the "kast" field.
func KastNotIn(vs ...int) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldKast), v...))
	})
}

// KastGT applies the GT predicate on the "kast" field.
func KastGT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldKast), v))
	})
}

// KastGTE applies the GTE predicate on the "kast" field.
func KastGTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldKast), v))
	})
}

// KastLT applies the LT predicate on the "kast" field.
func KastLT(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldKast), v))
	})
}

// KastLTE applies the LTE predicate on the "kast" field.
func KastLTE(v int) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldKast), v))
	})
}

// KastIsNil applies the IsNil predicate on the "kast" field.
func KastIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldKast)))
	})
}

// KastNotNil applies the NotNil predicate on the "kast" field.
func KastNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldKast)))
	})
}

// FlashDurationSelfEQ applies the EQ predicate on the "flash_duration_self" field.
func FlashDurationSelfEQ(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashDurationSelf), v))
	})
}

// FlashDurationSelfNEQ applies the NEQ predicate on the "flash_duration_self" field.
func FlashDurationSelfNEQ(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldFlashDurationSelf), v))
	})
}

// FlashDurationSelfIn applies the In predicate on the "flash_duration_self" field.
func FlashDurationSelfIn(vs ...float32) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldFlashDurationSelf), v...))
	})
}

// FlashDurationSelfNotIn applies the NotIn predicate on the "flash_duration_self" field.
func FlashDurationSelfNotIn(vs ...float32) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldFlashDurationSelf), v...))
	})
}

// FlashDurationSelfGT applies the GT predicate on the "flash_duration_self" field.
func FlashDurationSelfGT(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldFlashDurationSelf), v))
	})
}

// FlashDurationSelfGTE applies the GTE predicate on the "flash_duration_self" field.
func FlashDurationSelfGTE(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldFlashDurationSelf), v))
	})
}

// FlashDurationSelfLT applies the LT predicate on the "flash_duration_self" field.
func FlashDurationSelfLT(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldFlashDurationSelf), v))
	})
}

// FlashDurationSelfLTE applies the LTE predicate on the "flash_duration_self" field.
func FlashDurationSelfLTE(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldFlashDurationSelf), v))
	})
}

// FlashDurationSelfIsNil applies the IsNil predicate on the "flash_duration_self" field.
func FlashDurationSelfIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldFlashDurationSelf)))
	})
}

// FlashDurationSelfNotNil applies the NotNil predicate on the "flash_duration_self" field.
func FlashDurationSelfNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldFlashDurationSelf)))
	})
}

// FlashDurationTeamEQ applies the EQ predicate on the "flash_duration_team" field.
func FlashDurationTeamEQ(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashDurationTeam), v))
	})
}

// FlashDurationTeamNEQ applies the NEQ predicate on the "flash_duration_team" field.
func FlashDurationTeamNEQ(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldFlashDurationTeam), v))
	})
}

// FlashDurationTeamIn applies the In predicate on the "flash_duration_team" field.
func FlashDurationTeamIn(vs ...float32) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldFlashDurationTeam), v...))
	})
}

// FlashDurationTeamNotIn applies the NotIn predicate on the "flash_duration_team" field.
func FlashDurationTeamNotIn(vs ...float32) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldFlashDurationTeam), v...))
	})
}

// FlashDurationTeamGT applies the GT predicate on the "flash_duration_team" field.
func FlashDurationTeamGT(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldFlashDurationTeam), v))
	})
}

// FlashDurationTeamGTE applies the GTE predicate on the "flash_duration_team" field.
func FlashDurationTeamGTE(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldFlashDurationTeam), v))
	})
}

// FlashDurationTeamLT applies the LT predicate on the "flash_duration_team" field.
func FlashDurationTeamLT(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldFlashDurationTeam), v))
	})
}

// FlashDurationTeamLTE applies the LTE predicate on the "flash_duration_team" field.
func FlashDurationTeamLTE(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldFlashDurationTeam), v))
	})
}

// FlashDurationTeamIsNil applies the IsNil predicate on the "flash_duration_team" field.
func FlashDurationTeamIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldFlashDurationTeam)))
	})
}

// FlashDurationTeamNotNil applies the NotNil predicate on the "flash_duration_team" field.
func FlashDurationTeamNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldFlashDurationTeam)))
	})
}

// FlashDurationEnemyEQ applies the EQ predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyEQ(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashDurationEnemy), v))
	})
}

// FlashDurationEnemyNEQ applies the NEQ predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyNEQ(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldFlashDurationEnemy), v))
	})
}

// FlashDurationEnemyIn applies the In predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyIn(vs ...float32) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldFlashDurationEnemy), v...))
	})
}

// FlashDurationEnemyNotIn applies the NotIn predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyNotIn(vs ...float32) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldFlashDurationEnemy), v...))
	})
}

// FlashDurationEnemyGT applies the GT predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyGT(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldFlashDurationEnemy), v))
	})
}

// FlashDurationEnemyGTE applies the GTE predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyGTE(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldFlashDurationEnemy), v))
	})
}

// FlashDurationEnemyLT applies the LT predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyLT(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldFlashDurationEnemy), v))
	})
}

// FlashDurationEnemyLTE applies the LTE predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyLTE(v float32) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldFlashDurationEnemy), v))
	})
}

// FlashDurationEnemyIsNil applies the IsNil predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldFlashDurationEnemy)))
	})
}

// FlashDurationEnemyNotNil applies the NotNil predicate on the "flash_duration_enemy" field.
func FlashDurationEnemyNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldFlashDurationEnemy)))
	})
}

// FlashTotalSelfEQ applies the EQ predicate on the "flash_total_self" field.
func FlashTotalSelfEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashTotalSelf), v))
	})
}

// FlashTotalSelfNEQ applies the NEQ predicate on the "flash_total_self" field.
func FlashTotalSelfNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldFlashTotalSelf), v))
	})
}

// FlashTotalSelfIn applies the In predicate on the "flash_total_self" field.
func FlashTotalSelfIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldFlashTotalSelf), v...))
	})
}

// FlashTotalSelfNotIn applies the NotIn predicate on the "flash_total_self" field.
func FlashTotalSelfNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldFlashTotalSelf), v...))
	})
}

// FlashTotalSelfGT applies the GT predicate on the "flash_total_self" field.
func FlashTotalSelfGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldFlashTotalSelf), v))
	})
}

// FlashTotalSelfGTE applies the GTE predicate on the "flash_total_self" field.
func FlashTotalSelfGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldFlashTotalSelf), v))
	})
}

// FlashTotalSelfLT applies the LT predicate on the "flash_total_self" field.
func FlashTotalSelfLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldFlashTotalSelf), v))
	})
}

// FlashTotalSelfLTE applies the LTE predicate on the "flash_total_self" field.
func FlashTotalSelfLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldFlashTotalSelf), v))
	})
}

// FlashTotalSelfIsNil applies the IsNil predicate on the "flash_total_self" field.
func FlashTotalSelfIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldFlashTotalSelf)))
	})
}

// FlashTotalSelfNotNil applies the NotNil predicate on the "flash_total_self" field.
func FlashTotalSelfNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldFlashTotalSelf)))
	})
}

// FlashTotalTeamEQ applies the EQ predicate on the "flash_total_team" field.
func FlashTotalTeamEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashTotalTeam), v))
	})
}

// FlashTotalTeamNEQ applies the NEQ predicate on the "flash_total_team" field.
func FlashTotalTeamNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldFlashTotalTeam), v))
	})
}

// FlashTotalTeamIn applies the In predicate on the "flash_total_team" field.
func FlashTotalTeamIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldFlashTotalTeam), v...))
	})
}

// FlashTotalTeamNotIn applies the NotIn predicate on the "flash_total_team" field.
func FlashTotalTeamNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldFlashTotalTeam), v...))
	})
}

// FlashTotalTeamGT applies the GT predicate on the "flash_total_team" field.
func FlashTotalTeamGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldFlashTotalTeam), v))
	})
}

// FlashTotalTeamGTE applies the GTE predicate on the "flash_total_team" field.
func FlashTotalTeamGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldFlashTotalTeam), v))
	})
}

// FlashTotalTeamLT applies the LT predicate on the "flash_total_team" field.
func FlashTotalTeamLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldFlashTotalTeam), v))
	})
}

// FlashTotalTeamLTE applies the LTE predicate on the "flash_total_team" field.
func FlashTotalTeamLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldFlashTotalTeam), v))
	})
}

// FlashTotalTeamIsNil applies the IsNil predicate on the "flash_total_team" field.
func FlashTotalTeamIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldFlashTotalTeam)))
	})
}

// FlashTotalTeamNotNil applies the NotNil predicate on the "flash_total_team" field.
func FlashTotalTeamNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldFlashTotalTeam)))
	})
}

// FlashTotalEnemyEQ applies the EQ predicate on the "flash_total_enemy" field.
func FlashTotalEnemyEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldFlashTotalEnemy), v))
	})
}

// FlashTotalEnemyNEQ applies the NEQ predicate on the "flash_total_enemy" field.
func FlashTotalEnemyNEQ(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldFlashTotalEnemy), v))
	})
}

// FlashTotalEnemyIn applies the In predicate on the "flash_total_enemy" field.
func FlashTotalEnemyIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldFlashTotalEnemy), v...))
	})
}

// FlashTotalEnemyNotIn applies the NotIn predicate on the "flash_total_enemy" field.
func FlashTotalEnemyNotIn(vs ...uint) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldFlashTotalEnemy), v...))
	})
}

// FlashTotalEnemyGT applies the GT predicate on the "flash_total_enemy" field.
func FlashTotalEnemyGT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldFlashTotalEnemy), v))
	})
}

// FlashTotalEnemyGTE applies the GTE predicate on the "flash_total_enemy" field.
func FlashTotalEnemyGTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldFlashTotalEnemy), v))
	})
}

// FlashTotalEnemyLT applies the LT predicate on the "flash_total_enemy" field.
func FlashTotalEnemyLT(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldFlashTotalEnemy), v))
	})
}

// FlashTotalEnemyLTE applies the LTE predicate on the "flash_total_enemy" field.
func FlashTotalEnemyLTE(v uint) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldFlashTotalEnemy), v))
	})
}

// FlashTotalEnemyIsNil applies the IsNil predicate on the "flash_total_enemy" field.
func FlashTotalEnemyIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldFlashTotalEnemy)))
	})
}

// FlashTotalEnemyNotNil applies the NotNil predicate on the "flash_total_enemy" field.
func FlashTotalEnemyNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldFlashTotalEnemy)))
	})
}

// MatchStatsEQ applies the EQ predicate on the "match_stats" field.
func MatchStatsEQ(v uint64) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMatchStats), v))
	})
}

// MatchStatsNEQ applies the NEQ predicate on the "match_stats" field.
func MatchStatsNEQ(v uint64) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldMatchStats), v))
	})
}

// MatchStatsIn applies the In predicate on the "match_stats" field.
func MatchStatsIn(vs ...uint64) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldMatchStats), v...))
	})
}

// MatchStatsNotIn applies the NotIn predicate on the "match_stats" field.
func MatchStatsNotIn(vs ...uint64) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldMatchStats), v...))
	})
}

// MatchStatsIsNil applies the IsNil predicate on the "match_stats" field.
func MatchStatsIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldMatchStats)))
	})
}

// MatchStatsNotNil applies the NotNil predicate on the "match_stats" field.
func MatchStatsNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldMatchStats)))
	})
}

// PlayerStatsEQ applies the EQ predicate on the "player_stats" field.
func PlayerStatsEQ(v uint64) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPlayerStats), v))
	})
}

// PlayerStatsNEQ applies the NEQ predicate on the "player_stats" field.
func PlayerStatsNEQ(v uint64) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldPlayerStats), v))
	})
}

// PlayerStatsIn applies the In predicate on the "player_stats" field.
func PlayerStatsIn(vs ...uint64) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldPlayerStats), v...))
	})
}

// PlayerStatsNotIn applies the NotIn predicate on the "player_stats" field.
func PlayerStatsNotIn(vs ...uint64) predicate.Stats {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Stats(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldPlayerStats), v...))
	})
}

// PlayerStatsIsNil applies the IsNil predicate on the "player_stats" field.
func PlayerStatsIsNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldPlayerStats)))
	})
}

// PlayerStatsNotNil applies the NotNil predicate on the "player_stats" field.
func PlayerStatsNotNil() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldPlayerStats)))
	})
}

// HasMatches applies the HasEdge predicate on the "matches" edge.
func HasMatches() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(MatchesTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, MatchesTable, MatchesColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasMatchesWith applies the HasEdge predicate on the "matches" edge with a given conditions (other predicates).
func HasMatchesWith(preds ...predicate.Match) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(MatchesInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, MatchesTable, MatchesColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasPlayers applies the HasEdge predicate on the "players" edge.
func HasPlayers() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(PlayersTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, PlayersTable, PlayersColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasPlayersWith applies the HasEdge predicate on the "players" edge with a given conditions (other predicates).
func HasPlayersWith(preds ...predicate.Player) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(PlayersInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, PlayersTable, PlayersColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasWeaponStats applies the HasEdge predicate on the "weapon_stats" edge.
func HasWeaponStats() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(WeaponStatsTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, WeaponStatsTable, WeaponStatsColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasWeaponStatsWith applies the HasEdge predicate on the "weapon_stats" edge with a given conditions (other predicates).
func HasWeaponStatsWith(preds ...predicate.WeaponStats) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(WeaponStatsInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, WeaponStatsTable, WeaponStatsColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasRoundStats applies the HasEdge predicate on the "round_stats" edge.
func HasRoundStats() predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(RoundStatsTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, RoundStatsTable, RoundStatsColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasRoundStatsWith applies the HasEdge predicate on the "round_stats" edge with a given conditions (other predicates).
func HasRoundStatsWith(preds ...predicate.RoundStats) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(RoundStatsInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, RoundStatsTable, RoundStatsColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Stats) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for _, p := range predicates {
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Stats) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for i, p := range predicates {
			if i > 0 {
				s1.Or()
			}
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Not applies the not operator on the given predicate.
func Not(p predicate.Stats) predicate.Stats {
	return predicate.Stats(func(s *sql.Selector) {
		p(s.Not())
	})
}