// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.

package generated

import (
	"bytes"
	"context"
	"errors"
	"strconv"
	"sync"
	"sync/atomic"
	"time"

	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"
	"github.com/tribalwarshelp/shared/models"
	gqlparser "github.com/vektah/gqlparser/v2"
	"github.com/vektah/gqlparser/v2/ast"
)

// region    ************************** generated!.gotpl **************************

// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
	return &executableSchema{
		resolvers:  cfg.Resolvers,
		directives: cfg.Directives,
		complexity: cfg.Complexity,
	}
}

type Config struct {
	Resolvers  ResolverRoot
	Directives DirectiveRoot
	Complexity ComplexityRoot
}

type ResolverRoot interface {
	DailyPlayerStatsRecord() DailyPlayerStatsRecordResolver
	DailyTribeStatsRecord() DailyTribeStatsRecordResolver
	Ennoblement() EnnoblementResolver
	LiveEnnoblement() LiveEnnoblementResolver
	Player() PlayerResolver
	PlayerHistoryRecord() PlayerHistoryRecordResolver
	Query() QueryResolver
	Server() ServerResolver
	TribeChangeRecord() TribeChangeRecordResolver
	TribeHistoryRecord() TribeHistoryRecordResolver
	Village() VillageResolver
}

type DirectiveRoot struct {
}

type ComplexityRoot struct {
	Building struct {
		BuildTime       func(childComplexity int) int
		BuildTimeFactor func(childComplexity int) int
		Iron            func(childComplexity int) int
		IronFactor      func(childComplexity int) int
		MaxLevel        func(childComplexity int) int
		MinLevel        func(childComplexity int) int
		Pop             func(childComplexity int) int
		PopFactor       func(childComplexity int) int
		Stone           func(childComplexity int) int
		StoneFactor     func(childComplexity int) int
		Wood            func(childComplexity int) int
		WoodFactor      func(childComplexity int) int
	}

	BuildingConfig struct {
		Barracks   func(childComplexity int) int
		Farm       func(childComplexity int) int
		Garage     func(childComplexity int) int
		Hide       func(childComplexity int) int
		Iron       func(childComplexity int) int
		Main       func(childComplexity int) int
		Market     func(childComplexity int) int
		Place      func(childComplexity int) int
		Smith      func(childComplexity int) int
		Snob       func(childComplexity int) int
		Stable     func(childComplexity int) int
		Statue     func(childComplexity int) int
		Stone      func(childComplexity int) int
		Storage    func(childComplexity int) int
		Wall       func(childComplexity int) int
		Watchtower func(childComplexity int) int
		Wood       func(childComplexity int) int
	}

	DailyPlayerStats struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	DailyPlayerStatsRecord struct {
		CreateDate func(childComplexity int) int
		Player     func(childComplexity int) int
		Points     func(childComplexity int) int
		Rank       func(childComplexity int) int
		RankAtt    func(childComplexity int) int
		RankDef    func(childComplexity int) int
		RankSup    func(childComplexity int) int
		RankTotal  func(childComplexity int) int
		ScoreAtt   func(childComplexity int) int
		ScoreDef   func(childComplexity int) int
		ScoreSup   func(childComplexity int) int
		ScoreTotal func(childComplexity int) int
		Villages   func(childComplexity int) int
	}

	DailyTribeStats struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	DailyTribeStatsRecord struct {
		AllPoints  func(childComplexity int) int
		CreateDate func(childComplexity int) int
		Dominance  func(childComplexity int) int
		Members    func(childComplexity int) int
		Points     func(childComplexity int) int
		Rank       func(childComplexity int) int
		RankAtt    func(childComplexity int) int
		RankDef    func(childComplexity int) int
		RankTotal  func(childComplexity int) int
		ScoreAtt   func(childComplexity int) int
		ScoreDef   func(childComplexity int) int
		ScoreTotal func(childComplexity int) int
		Tribe      func(childComplexity int) int
		Villages   func(childComplexity int) int
	}

	Ennoblement struct {
		EnnobledAt    func(childComplexity int) int
		NewOwner      func(childComplexity int) int
		NewOwnerTribe func(childComplexity int) int
		OldOwner      func(childComplexity int) int
		OldOwnerTribe func(childComplexity int) int
		Village       func(childComplexity int) int
	}

	EnnoblementList struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	LangVersion struct {
		Host     func(childComplexity int) int
		Name     func(childComplexity int) int
		Tag      func(childComplexity int) int
		Timezone func(childComplexity int) int
	}

	LangVersionList struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	LiveEnnoblement struct {
		EnnobledAt func(childComplexity int) int
		NewOwner   func(childComplexity int) int
		OldOwner   func(childComplexity int) int
		Village    func(childComplexity int) int
	}

	Player struct {
		BestRank       func(childComplexity int) int
		BestRankAt     func(childComplexity int) int
		DailyGrowth    func(childComplexity int) int
		DeletedAt      func(childComplexity int) int
		Exists         func(childComplexity int) int
		ID             func(childComplexity int) int
		JoinedAt       func(childComplexity int) int
		MostPoints     func(childComplexity int) int
		MostPointsAt   func(childComplexity int) int
		MostVillages   func(childComplexity int) int
		MostVillagesAt func(childComplexity int) int
		Name           func(childComplexity int) int
		NameChanges    func(childComplexity int) int
		Points         func(childComplexity int) int
		Rank           func(childComplexity int) int
		RankAtt        func(childComplexity int) int
		RankDef        func(childComplexity int) int
		RankSup        func(childComplexity int) int
		RankTotal      func(childComplexity int) int
		ScoreAtt       func(childComplexity int) int
		ScoreDef       func(childComplexity int) int
		ScoreSup       func(childComplexity int) int
		ScoreTotal     func(childComplexity int) int
		Servers        func(childComplexity int) int
		TotalVillages  func(childComplexity int) int
		Tribe          func(childComplexity int) int
	}

	PlayerHistory struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	PlayerHistoryRecord struct {
		CreateDate    func(childComplexity int) int
		Player        func(childComplexity int) int
		Points        func(childComplexity int) int
		Rank          func(childComplexity int) int
		RankAtt       func(childComplexity int) int
		RankDef       func(childComplexity int) int
		RankSup       func(childComplexity int) int
		RankTotal     func(childComplexity int) int
		ScoreAtt      func(childComplexity int) int
		ScoreDef      func(childComplexity int) int
		ScoreSup      func(childComplexity int) int
		ScoreTotal    func(childComplexity int) int
		TotalVillages func(childComplexity int) int
		Tribe         func(childComplexity int) int
	}

	PlayerList struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	PlayerNameChange struct {
		ChangeDate func(childComplexity int) int
		NewName    func(childComplexity int) int
		OldName    func(childComplexity int) int
	}

	Query struct {
		DailyPlayerStats func(childComplexity int, server string, filter *models.DailyPlayerStatsFilter) int
		DailyTribeStats  func(childComplexity int, server string, filter *models.DailyTribeStatsFilter) int
		Ennoblements     func(childComplexity int, server string, filter *models.EnnoblementFilter) int
		LangVersion      func(childComplexity int, tag models.LanguageTag) int
		LangVersions     func(childComplexity int, filter *models.LangVersionFilter) int
		LiveEnnoblements func(childComplexity int, server string) int
		Player           func(childComplexity int, server string, id int) int
		PlayerHistory    func(childComplexity int, server string, filter *models.PlayerHistoryFilter) int
		Players          func(childComplexity int, server string, filter *models.PlayerFilter) int
		Server           func(childComplexity int, key string) int
		ServerStats      func(childComplexity int, server string, filter *models.ServerStatsFilter) int
		Servers          func(childComplexity int, filter *models.ServerFilter) int
		Tribe            func(childComplexity int, server string, id int) int
		TribeChanges     func(childComplexity int, server string, filter *models.TribeChangeFilter) int
		TribeHistory     func(childComplexity int, server string, filter *models.TribeHistoryFilter) int
		Tribes           func(childComplexity int, server string, filter *models.TribeFilter) int
		Village          func(childComplexity int, server string, id int) int
		Villages         func(childComplexity int, server string, filter *models.VillageFilter) int
	}

	Server struct {
		BuildingConfig   func(childComplexity int) int
		Config           func(childComplexity int) int
		DataUpdatedAt    func(childComplexity int) int
		HistoryUpdatedAt func(childComplexity int) int
		Key              func(childComplexity int) int
		LangVersion      func(childComplexity int) int
		NumberOfPlayers  func(childComplexity int) int
		NumberOfTribes   func(childComplexity int) int
		NumberOfVillages func(childComplexity int) int
		StatsUpdatedAt   func(childComplexity int) int
		Status           func(childComplexity int) int
		UnitConfig       func(childComplexity int) int
	}

	ServerConfig struct {
		Ally      func(childComplexity int) int
		Build     func(childComplexity int) int
		Buildings func(childComplexity int) int
		Commands  func(childComplexity int) int
		Coord     func(childComplexity int) int
		Game      func(childComplexity int) int
		Misc      func(childComplexity int) int
		Moral     func(childComplexity int) int
		Newbie    func(childComplexity int) int
		Night     func(childComplexity int) int
		Sitter    func(childComplexity int) int
		Sleep     func(childComplexity int) int
		Snob      func(childComplexity int) int
		Speed     func(childComplexity int) int
		UnitSpeed func(childComplexity int) int
		Win       func(childComplexity int) int
	}

	ServerConfigAlly struct {
		AllytimeSupport       func(childComplexity int) int
		FixedAllies           func(childComplexity int) int
		Levels                func(childComplexity int) int
		Limit                 func(childComplexity int) int
		NoHarm                func(childComplexity int) int
		NoJoin                func(childComplexity int) int
		NoLeave               func(childComplexity int) int
		NoOtherSupport        func(childComplexity int) int
		PointsMemberCount     func(childComplexity int) int
		WarsAutoacceptDays    func(childComplexity int) int
		WarsMemberRequirement func(childComplexity int) int
		WarsPointsRequirement func(childComplexity int) int
		XpRequirements        func(childComplexity int) int
	}

	ServerConfigBuild struct {
		Destroy func(childComplexity int) int
	}

	ServerConfigBuildings struct {
		CustomBarracks   func(childComplexity int) int
		CustomChurch     func(childComplexity int) int
		CustomFarm       func(childComplexity int) int
		CustomGarage     func(childComplexity int) int
		CustomHide       func(childComplexity int) int
		CustomIron       func(childComplexity int) int
		CustomMain       func(childComplexity int) int
		CustomMarket     func(childComplexity int) int
		CustomPlace      func(childComplexity int) int
		CustomSmith      func(childComplexity int) int
		CustomSnob       func(childComplexity int) int
		CustomStable     func(childComplexity int) int
		CustomStatue     func(childComplexity int) int
		CustomStone      func(childComplexity int) int
		CustomStorage    func(childComplexity int) int
		CustomWall       func(childComplexity int) int
		CustomWatchtower func(childComplexity int) int
		CustomWood       func(childComplexity int) int
	}

	ServerConfigCommands struct {
		CommandCancelTime func(childComplexity int) int
		MillisArrival     func(childComplexity int) int
	}

	ServerConfigCoord struct {
		BonusNew        func(childComplexity int) int
		BonusVillages   func(childComplexity int) int
		EmptyVillages   func(childComplexity int) int
		Func            func(childComplexity int) int
		Inner           func(childComplexity int) int
		MapSize         func(childComplexity int) int
		NobleRestart    func(childComplexity int) int
		SelectStart     func(childComplexity int) int
		StartVillages   func(childComplexity int) int
		VillageMoveWait func(childComplexity int) int
	}

	ServerConfigGame struct {
		Archer             func(childComplexity int) int
		BarbarianMaxPoints func(childComplexity int) int
		BarbarianRise      func(childComplexity int) int
		BarbarianShrink    func(childComplexity int) int
		BaseProduction     func(childComplexity int) int
		BuildtimeFormula   func(childComplexity int) int
		Church             func(childComplexity int) int
		Event              func(childComplexity int) int
		FakeLimit          func(childComplexity int) int
		FarmLimit          func(childComplexity int) int
		Hauls              func(childComplexity int) int
		HaulsBase          func(childComplexity int) int
		HaulsMax           func(childComplexity int) int
		Knight             func(childComplexity int) int
		KnightNewItems     func(childComplexity int) int
		Stronghold         func(childComplexity int) int
		SuppressEvents     func(childComplexity int) int
		Tech               func(childComplexity int) int
		Watchtower         func(childComplexity int) int
	}

	ServerConfigMisc struct {
		KillRanking     func(childComplexity int) int
		TradeCancelTime func(childComplexity int) int
		Tutorial        func(childComplexity int) int
	}

	ServerConfigNewbie struct {
		Days                 func(childComplexity int) int
		Ratio                func(childComplexity int) int
		RatioDays            func(childComplexity int) int
		RemoveNewbieVillages func(childComplexity int) int
	}

	ServerConfigNight struct {
		Active    func(childComplexity int) int
		DefFactor func(childComplexity int) int
		EndHour   func(childComplexity int) int
		StartHour func(childComplexity int) int
	}

	ServerConfigSitter struct {
		Allow func(childComplexity int) int
	}

	ServerConfigSleep struct {
		Active   func(childComplexity int) int
		Delay    func(childComplexity int) int
		Max      func(childComplexity int) int
		MaxAwake func(childComplexity int) int
		Min      func(childComplexity int) int
		MinAwake func(childComplexity int) int
		WarnTime func(childComplexity int) int
	}

	ServerConfigSnob struct {
		CheapRebuild  func(childComplexity int) int
		CoinIron      func(childComplexity int) int
		CoinStone     func(childComplexity int) int
		CoinWood      func(childComplexity int) int
		Factor        func(childComplexity int) int
		Gold          func(childComplexity int) int
		MaxDist       func(childComplexity int) int
		NoBarbConquer func(childComplexity int) int
		Rise          func(childComplexity int) int
	}

	ServerConfigWin struct {
		Check func(childComplexity int) int
	}

	ServerList struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	ServerStats struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	ServerStatsRecord struct {
		ActivePlayers     func(childComplexity int) int
		ActiveTribes      func(childComplexity int) int
		BarbarianVillages func(childComplexity int) int
		BonusVillages     func(childComplexity int) int
		CreateDate        func(childComplexity int) int
		InactivePlayers   func(childComplexity int) int
		InactiveTribes    func(childComplexity int) int
		PlayerVillages    func(childComplexity int) int
		Players           func(childComplexity int) int
		Tribes            func(childComplexity int) int
		Villages          func(childComplexity int) int
	}

	Tribe struct {
		AllPoints      func(childComplexity int) int
		BestRank       func(childComplexity int) int
		BestRankAt     func(childComplexity int) int
		CreatedAt      func(childComplexity int) int
		DeletedAt      func(childComplexity int) int
		Dominance      func(childComplexity int) int
		Exists         func(childComplexity int) int
		ID             func(childComplexity int) int
		MostPoints     func(childComplexity int) int
		MostPointsAt   func(childComplexity int) int
		MostVillages   func(childComplexity int) int
		MostVillagesAt func(childComplexity int) int
		Name           func(childComplexity int) int
		Points         func(childComplexity int) int
		Rank           func(childComplexity int) int
		RankAtt        func(childComplexity int) int
		RankDef        func(childComplexity int) int
		RankTotal      func(childComplexity int) int
		ScoreAtt       func(childComplexity int) int
		ScoreDef       func(childComplexity int) int
		ScoreTotal     func(childComplexity int) int
		Tag            func(childComplexity int) int
		TotalMembers   func(childComplexity int) int
		TotalVillages  func(childComplexity int) int
	}

	TribeChangeRecord struct {
		CreatedAt func(childComplexity int) int
		NewTribe  func(childComplexity int) int
		OldTribe  func(childComplexity int) int
		Player    func(childComplexity int) int
	}

	TribeChanges struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	TribeHistory struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	TribeHistoryRecord struct {
		AllPoints     func(childComplexity int) int
		CreateDate    func(childComplexity int) int
		Dominance     func(childComplexity int) int
		Points        func(childComplexity int) int
		Rank          func(childComplexity int) int
		RankAtt       func(childComplexity int) int
		RankDef       func(childComplexity int) int
		RankTotal     func(childComplexity int) int
		ScoreAtt      func(childComplexity int) int
		ScoreDef      func(childComplexity int) int
		ScoreTotal    func(childComplexity int) int
		TotalMembers  func(childComplexity int) int
		TotalVillages func(childComplexity int) int
		Tribe         func(childComplexity int) int
	}

	TribeList struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}

	Unit struct {
		Attack         func(childComplexity int) int
		BuildTime      func(childComplexity int) int
		Carry          func(childComplexity int) int
		Defense        func(childComplexity int) int
		DefenseArcher  func(childComplexity int) int
		DefenseCavalry func(childComplexity int) int
		Pop            func(childComplexity int) int
		Speed          func(childComplexity int) int
	}

	UnitConfig struct {
		Archer   func(childComplexity int) int
		Axe      func(childComplexity int) int
		Catapult func(childComplexity int) int
		Heavy    func(childComplexity int) int
		Knight   func(childComplexity int) int
		Light    func(childComplexity int) int
		Marcher  func(childComplexity int) int
		Militia  func(childComplexity int) int
		Ram      func(childComplexity int) int
		Snob     func(childComplexity int) int
		Spear    func(childComplexity int) int
		Spy      func(childComplexity int) int
		Sword    func(childComplexity int) int
	}

	Village struct {
		Bonus  func(childComplexity int) int
		ID     func(childComplexity int) int
		Name   func(childComplexity int) int
		Player func(childComplexity int) int
		Points func(childComplexity int) int
		X      func(childComplexity int) int
		Y      func(childComplexity int) int
	}

	VillageList struct {
		Items func(childComplexity int) int
		Total func(childComplexity int) int
	}
}

type DailyPlayerStatsRecordResolver interface {
	Player(ctx context.Context, obj *models.DailyPlayerStats) (*models.Player, error)
}
type DailyTribeStatsRecordResolver interface {
	Tribe(ctx context.Context, obj *models.DailyTribeStats) (*models.Tribe, error)
}
type EnnoblementResolver interface {
	Village(ctx context.Context, obj *models.Ennoblement) (*models.Village, error)
	NewOwner(ctx context.Context, obj *models.Ennoblement) (*models.Player, error)
	NewOwnerTribe(ctx context.Context, obj *models.Ennoblement) (*models.Tribe, error)
	OldOwner(ctx context.Context, obj *models.Ennoblement) (*models.Player, error)
	OldOwnerTribe(ctx context.Context, obj *models.Ennoblement) (*models.Tribe, error)
}
type LiveEnnoblementResolver interface {
	Village(ctx context.Context, obj *models.LiveEnnoblement) (*models.Village, error)
	NewOwner(ctx context.Context, obj *models.LiveEnnoblement) (*models.Player, error)
	OldOwner(ctx context.Context, obj *models.LiveEnnoblement) (*models.Player, error)
}
type PlayerResolver interface {
	Tribe(ctx context.Context, obj *models.Player) (*models.Tribe, error)
	Servers(ctx context.Context, obj *models.Player) ([]string, error)
	NameChanges(ctx context.Context, obj *models.Player) ([]*models.PlayerNameChange, error)
}
type PlayerHistoryRecordResolver interface {
	Player(ctx context.Context, obj *models.PlayerHistory) (*models.Player, error)

	Tribe(ctx context.Context, obj *models.PlayerHistory) (*models.Tribe, error)
}
type QueryResolver interface {
	DailyPlayerStats(ctx context.Context, server string, filter *models.DailyPlayerStatsFilter) (*DailyPlayerStats, error)
	DailyTribeStats(ctx context.Context, server string, filter *models.DailyTribeStatsFilter) (*DailyTribeStats, error)
	Ennoblements(ctx context.Context, server string, filter *models.EnnoblementFilter) (*EnnoblementList, error)
	LangVersions(ctx context.Context, filter *models.LangVersionFilter) (*LangVersionList, error)
	LangVersion(ctx context.Context, tag models.LanguageTag) (*models.LangVersion, error)
	LiveEnnoblements(ctx context.Context, server string) ([]*models.LiveEnnoblement, error)
	Players(ctx context.Context, server string, filter *models.PlayerFilter) (*PlayerList, error)
	Player(ctx context.Context, server string, id int) (*models.Player, error)
	PlayerHistory(ctx context.Context, server string, filter *models.PlayerHistoryFilter) (*PlayerHistory, error)
	Servers(ctx context.Context, filter *models.ServerFilter) (*ServerList, error)
	Server(ctx context.Context, key string) (*models.Server, error)
	ServerStats(ctx context.Context, server string, filter *models.ServerStatsFilter) (*ServerStats, error)
	Tribes(ctx context.Context, server string, filter *models.TribeFilter) (*TribeList, error)
	Tribe(ctx context.Context, server string, id int) (*models.Tribe, error)
	TribeChanges(ctx context.Context, server string, filter *models.TribeChangeFilter) (*TribeChanges, error)
	TribeHistory(ctx context.Context, server string, filter *models.TribeHistoryFilter) (*TribeHistory, error)
	Villages(ctx context.Context, server string, filter *models.VillageFilter) (*VillageList, error)
	Village(ctx context.Context, server string, id int) (*models.Village, error)
}
type ServerResolver interface {
	LangVersion(ctx context.Context, obj *models.Server) (*models.LangVersion, error)
}
type TribeChangeRecordResolver interface {
	Player(ctx context.Context, obj *models.TribeChange) (*models.Player, error)
	OldTribe(ctx context.Context, obj *models.TribeChange) (*models.Tribe, error)
	NewTribe(ctx context.Context, obj *models.TribeChange) (*models.Tribe, error)
}
type TribeHistoryRecordResolver interface {
	Tribe(ctx context.Context, obj *models.TribeHistory) (*models.Tribe, error)
}
type VillageResolver interface {
	Player(ctx context.Context, obj *models.Village) (*models.Player, error)
}

type executableSchema struct {
	resolvers  ResolverRoot
	directives DirectiveRoot
	complexity ComplexityRoot
}

func (e *executableSchema) Schema() *ast.Schema {
	return parsedSchema
}

func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
	ec := executionContext{nil, e}
	_ = ec
	switch typeName + "." + field {

	case "Building.buildTime":
		if e.complexity.Building.BuildTime == nil {
			break
		}

		return e.complexity.Building.BuildTime(childComplexity), true

	case "Building.buildTimeFactor":
		if e.complexity.Building.BuildTimeFactor == nil {
			break
		}

		return e.complexity.Building.BuildTimeFactor(childComplexity), true

	case "Building.iron":
		if e.complexity.Building.Iron == nil {
			break
		}

		return e.complexity.Building.Iron(childComplexity), true

	case "Building.ironFactor":
		if e.complexity.Building.IronFactor == nil {
			break
		}

		return e.complexity.Building.IronFactor(childComplexity), true

	case "Building.maxLevel":
		if e.complexity.Building.MaxLevel == nil {
			break
		}

		return e.complexity.Building.MaxLevel(childComplexity), true

	case "Building.minLevel":
		if e.complexity.Building.MinLevel == nil {
			break
		}

		return e.complexity.Building.MinLevel(childComplexity), true

	case "Building.pop":
		if e.complexity.Building.Pop == nil {
			break
		}

		return e.complexity.Building.Pop(childComplexity), true

	case "Building.popFactor":
		if e.complexity.Building.PopFactor == nil {
			break
		}

		return e.complexity.Building.PopFactor(childComplexity), true

	case "Building.stone":
		if e.complexity.Building.Stone == nil {
			break
		}

		return e.complexity.Building.Stone(childComplexity), true

	case "Building.stoneFactor":
		if e.complexity.Building.StoneFactor == nil {
			break
		}

		return e.complexity.Building.StoneFactor(childComplexity), true

	case "Building.wood":
		if e.complexity.Building.Wood == nil {
			break
		}

		return e.complexity.Building.Wood(childComplexity), true

	case "Building.woodFactor":
		if e.complexity.Building.WoodFactor == nil {
			break
		}

		return e.complexity.Building.WoodFactor(childComplexity), true

	case "BuildingConfig.barracks":
		if e.complexity.BuildingConfig.Barracks == nil {
			break
		}

		return e.complexity.BuildingConfig.Barracks(childComplexity), true

	case "BuildingConfig.farm":
		if e.complexity.BuildingConfig.Farm == nil {
			break
		}

		return e.complexity.BuildingConfig.Farm(childComplexity), true

	case "BuildingConfig.garage":
		if e.complexity.BuildingConfig.Garage == nil {
			break
		}

		return e.complexity.BuildingConfig.Garage(childComplexity), true

	case "BuildingConfig.hide":
		if e.complexity.BuildingConfig.Hide == nil {
			break
		}

		return e.complexity.BuildingConfig.Hide(childComplexity), true

	case "BuildingConfig.iron":
		if e.complexity.BuildingConfig.Iron == nil {
			break
		}

		return e.complexity.BuildingConfig.Iron(childComplexity), true

	case "BuildingConfig.main":
		if e.complexity.BuildingConfig.Main == nil {
			break
		}

		return e.complexity.BuildingConfig.Main(childComplexity), true

	case "BuildingConfig.market":
		if e.complexity.BuildingConfig.Market == nil {
			break
		}

		return e.complexity.BuildingConfig.Market(childComplexity), true

	case "BuildingConfig.place":
		if e.complexity.BuildingConfig.Place == nil {
			break
		}

		return e.complexity.BuildingConfig.Place(childComplexity), true

	case "BuildingConfig.smith":
		if e.complexity.BuildingConfig.Smith == nil {
			break
		}

		return e.complexity.BuildingConfig.Smith(childComplexity), true

	case "BuildingConfig.snob":
		if e.complexity.BuildingConfig.Snob == nil {
			break
		}

		return e.complexity.BuildingConfig.Snob(childComplexity), true

	case "BuildingConfig.stable":
		if e.complexity.BuildingConfig.Stable == nil {
			break
		}

		return e.complexity.BuildingConfig.Stable(childComplexity), true

	case "BuildingConfig.statue":
		if e.complexity.BuildingConfig.Statue == nil {
			break
		}

		return e.complexity.BuildingConfig.Statue(childComplexity), true

	case "BuildingConfig.stone":
		if e.complexity.BuildingConfig.Stone == nil {
			break
		}

		return e.complexity.BuildingConfig.Stone(childComplexity), true

	case "BuildingConfig.storage":
		if e.complexity.BuildingConfig.Storage == nil {
			break
		}

		return e.complexity.BuildingConfig.Storage(childComplexity), true

	case "BuildingConfig.wall":
		if e.complexity.BuildingConfig.Wall == nil {
			break
		}

		return e.complexity.BuildingConfig.Wall(childComplexity), true

	case "BuildingConfig.watchtower":
		if e.complexity.BuildingConfig.Watchtower == nil {
			break
		}

		return e.complexity.BuildingConfig.Watchtower(childComplexity), true

	case "BuildingConfig.wood":
		if e.complexity.BuildingConfig.Wood == nil {
			break
		}

		return e.complexity.BuildingConfig.Wood(childComplexity), true

	case "DailyPlayerStats.items":
		if e.complexity.DailyPlayerStats.Items == nil {
			break
		}

		return e.complexity.DailyPlayerStats.Items(childComplexity), true

	case "DailyPlayerStats.total":
		if e.complexity.DailyPlayerStats.Total == nil {
			break
		}

		return e.complexity.DailyPlayerStats.Total(childComplexity), true

	case "DailyPlayerStatsRecord.createDate":
		if e.complexity.DailyPlayerStatsRecord.CreateDate == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.CreateDate(childComplexity), true

	case "DailyPlayerStatsRecord.player":
		if e.complexity.DailyPlayerStatsRecord.Player == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.Player(childComplexity), true

	case "DailyPlayerStatsRecord.points":
		if e.complexity.DailyPlayerStatsRecord.Points == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.Points(childComplexity), true

	case "DailyPlayerStatsRecord.rank":
		if e.complexity.DailyPlayerStatsRecord.Rank == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.Rank(childComplexity), true

	case "DailyPlayerStatsRecord.rankAtt":
		if e.complexity.DailyPlayerStatsRecord.RankAtt == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.RankAtt(childComplexity), true

	case "DailyPlayerStatsRecord.rankDef":
		if e.complexity.DailyPlayerStatsRecord.RankDef == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.RankDef(childComplexity), true

	case "DailyPlayerStatsRecord.rankSup":
		if e.complexity.DailyPlayerStatsRecord.RankSup == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.RankSup(childComplexity), true

	case "DailyPlayerStatsRecord.rankTotal":
		if e.complexity.DailyPlayerStatsRecord.RankTotal == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.RankTotal(childComplexity), true

	case "DailyPlayerStatsRecord.scoreAtt":
		if e.complexity.DailyPlayerStatsRecord.ScoreAtt == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.ScoreAtt(childComplexity), true

	case "DailyPlayerStatsRecord.scoreDef":
		if e.complexity.DailyPlayerStatsRecord.ScoreDef == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.ScoreDef(childComplexity), true

	case "DailyPlayerStatsRecord.scoreSup":
		if e.complexity.DailyPlayerStatsRecord.ScoreSup == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.ScoreSup(childComplexity), true

	case "DailyPlayerStatsRecord.scoreTotal":
		if e.complexity.DailyPlayerStatsRecord.ScoreTotal == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.ScoreTotal(childComplexity), true

	case "DailyPlayerStatsRecord.villages":
		if e.complexity.DailyPlayerStatsRecord.Villages == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.Villages(childComplexity), true

	case "DailyTribeStats.items":
		if e.complexity.DailyTribeStats.Items == nil {
			break
		}

		return e.complexity.DailyTribeStats.Items(childComplexity), true

	case "DailyTribeStats.total":
		if e.complexity.DailyTribeStats.Total == nil {
			break
		}

		return e.complexity.DailyTribeStats.Total(childComplexity), true

	case "DailyTribeStatsRecord.allPoints":
		if e.complexity.DailyTribeStatsRecord.AllPoints == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.AllPoints(childComplexity), true

	case "DailyTribeStatsRecord.createDate":
		if e.complexity.DailyTribeStatsRecord.CreateDate == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.CreateDate(childComplexity), true

	case "DailyTribeStatsRecord.dominance":
		if e.complexity.DailyTribeStatsRecord.Dominance == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.Dominance(childComplexity), true

	case "DailyTribeStatsRecord.members":
		if e.complexity.DailyTribeStatsRecord.Members == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.Members(childComplexity), true

	case "DailyTribeStatsRecord.points":
		if e.complexity.DailyTribeStatsRecord.Points == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.Points(childComplexity), true

	case "DailyTribeStatsRecord.rank":
		if e.complexity.DailyTribeStatsRecord.Rank == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.Rank(childComplexity), true

	case "DailyTribeStatsRecord.rankAtt":
		if e.complexity.DailyTribeStatsRecord.RankAtt == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.RankAtt(childComplexity), true

	case "DailyTribeStatsRecord.rankDef":
		if e.complexity.DailyTribeStatsRecord.RankDef == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.RankDef(childComplexity), true

	case "DailyTribeStatsRecord.rankTotal":
		if e.complexity.DailyTribeStatsRecord.RankTotal == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.RankTotal(childComplexity), true

	case "DailyTribeStatsRecord.scoreAtt":
		if e.complexity.DailyTribeStatsRecord.ScoreAtt == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.ScoreAtt(childComplexity), true

	case "DailyTribeStatsRecord.scoreDef":
		if e.complexity.DailyTribeStatsRecord.ScoreDef == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.ScoreDef(childComplexity), true

	case "DailyTribeStatsRecord.scoreTotal":
		if e.complexity.DailyTribeStatsRecord.ScoreTotal == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.ScoreTotal(childComplexity), true

	case "DailyTribeStatsRecord.tribe":
		if e.complexity.DailyTribeStatsRecord.Tribe == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.Tribe(childComplexity), true

	case "DailyTribeStatsRecord.villages":
		if e.complexity.DailyTribeStatsRecord.Villages == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.Villages(childComplexity), true

	case "Ennoblement.ennobledAt":
		if e.complexity.Ennoblement.EnnobledAt == nil {
			break
		}

		return e.complexity.Ennoblement.EnnobledAt(childComplexity), true

	case "Ennoblement.newOwner":
		if e.complexity.Ennoblement.NewOwner == nil {
			break
		}

		return e.complexity.Ennoblement.NewOwner(childComplexity), true

	case "Ennoblement.newOwnerTribe":
		if e.complexity.Ennoblement.NewOwnerTribe == nil {
			break
		}

		return e.complexity.Ennoblement.NewOwnerTribe(childComplexity), true

	case "Ennoblement.oldOwner":
		if e.complexity.Ennoblement.OldOwner == nil {
			break
		}

		return e.complexity.Ennoblement.OldOwner(childComplexity), true

	case "Ennoblement.oldOwnerTribe":
		if e.complexity.Ennoblement.OldOwnerTribe == nil {
			break
		}

		return e.complexity.Ennoblement.OldOwnerTribe(childComplexity), true

	case "Ennoblement.village":
		if e.complexity.Ennoblement.Village == nil {
			break
		}

		return e.complexity.Ennoblement.Village(childComplexity), true

	case "EnnoblementList.items":
		if e.complexity.EnnoblementList.Items == nil {
			break
		}

		return e.complexity.EnnoblementList.Items(childComplexity), true

	case "EnnoblementList.total":
		if e.complexity.EnnoblementList.Total == nil {
			break
		}

		return e.complexity.EnnoblementList.Total(childComplexity), true

	case "LangVersion.host":
		if e.complexity.LangVersion.Host == nil {
			break
		}

		return e.complexity.LangVersion.Host(childComplexity), true

	case "LangVersion.name":
		if e.complexity.LangVersion.Name == nil {
			break
		}

		return e.complexity.LangVersion.Name(childComplexity), true

	case "LangVersion.tag":
		if e.complexity.LangVersion.Tag == nil {
			break
		}

		return e.complexity.LangVersion.Tag(childComplexity), true

	case "LangVersion.timezone":
		if e.complexity.LangVersion.Timezone == nil {
			break
		}

		return e.complexity.LangVersion.Timezone(childComplexity), true

	case "LangVersionList.items":
		if e.complexity.LangVersionList.Items == nil {
			break
		}

		return e.complexity.LangVersionList.Items(childComplexity), true

	case "LangVersionList.total":
		if e.complexity.LangVersionList.Total == nil {
			break
		}

		return e.complexity.LangVersionList.Total(childComplexity), true

	case "LiveEnnoblement.ennobledAt":
		if e.complexity.LiveEnnoblement.EnnobledAt == nil {
			break
		}

		return e.complexity.LiveEnnoblement.EnnobledAt(childComplexity), true

	case "LiveEnnoblement.newOwner":
		if e.complexity.LiveEnnoblement.NewOwner == nil {
			break
		}

		return e.complexity.LiveEnnoblement.NewOwner(childComplexity), true

	case "LiveEnnoblement.oldOwner":
		if e.complexity.LiveEnnoblement.OldOwner == nil {
			break
		}

		return e.complexity.LiveEnnoblement.OldOwner(childComplexity), true

	case "LiveEnnoblement.village":
		if e.complexity.LiveEnnoblement.Village == nil {
			break
		}

		return e.complexity.LiveEnnoblement.Village(childComplexity), true

	case "Player.bestRank":
		if e.complexity.Player.BestRank == nil {
			break
		}

		return e.complexity.Player.BestRank(childComplexity), true

	case "Player.bestRankAt":
		if e.complexity.Player.BestRankAt == nil {
			break
		}

		return e.complexity.Player.BestRankAt(childComplexity), true

	case "Player.dailyGrowth":
		if e.complexity.Player.DailyGrowth == nil {
			break
		}

		return e.complexity.Player.DailyGrowth(childComplexity), true

	case "Player.deletedAt":
		if e.complexity.Player.DeletedAt == nil {
			break
		}

		return e.complexity.Player.DeletedAt(childComplexity), true

	case "Player.exists":
		if e.complexity.Player.Exists == nil {
			break
		}

		return e.complexity.Player.Exists(childComplexity), true

	case "Player.id":
		if e.complexity.Player.ID == nil {
			break
		}

		return e.complexity.Player.ID(childComplexity), true

	case "Player.joinedAt":
		if e.complexity.Player.JoinedAt == nil {
			break
		}

		return e.complexity.Player.JoinedAt(childComplexity), true

	case "Player.mostPoints":
		if e.complexity.Player.MostPoints == nil {
			break
		}

		return e.complexity.Player.MostPoints(childComplexity), true

	case "Player.mostPointsAt":
		if e.complexity.Player.MostPointsAt == nil {
			break
		}

		return e.complexity.Player.MostPointsAt(childComplexity), true

	case "Player.mostVillages":
		if e.complexity.Player.MostVillages == nil {
			break
		}

		return e.complexity.Player.MostVillages(childComplexity), true

	case "Player.mostVillagesAt":
		if e.complexity.Player.MostVillagesAt == nil {
			break
		}

		return e.complexity.Player.MostVillagesAt(childComplexity), true

	case "Player.name":
		if e.complexity.Player.Name == nil {
			break
		}

		return e.complexity.Player.Name(childComplexity), true

	case "Player.nameChanges":
		if e.complexity.Player.NameChanges == nil {
			break
		}

		return e.complexity.Player.NameChanges(childComplexity), true

	case "Player.points":
		if e.complexity.Player.Points == nil {
			break
		}

		return e.complexity.Player.Points(childComplexity), true

	case "Player.rank":
		if e.complexity.Player.Rank == nil {
			break
		}

		return e.complexity.Player.Rank(childComplexity), true

	case "Player.rankAtt":
		if e.complexity.Player.RankAtt == nil {
			break
		}

		return e.complexity.Player.RankAtt(childComplexity), true

	case "Player.rankDef":
		if e.complexity.Player.RankDef == nil {
			break
		}

		return e.complexity.Player.RankDef(childComplexity), true

	case "Player.rankSup":
		if e.complexity.Player.RankSup == nil {
			break
		}

		return e.complexity.Player.RankSup(childComplexity), true

	case "Player.rankTotal":
		if e.complexity.Player.RankTotal == nil {
			break
		}

		return e.complexity.Player.RankTotal(childComplexity), true

	case "Player.scoreAtt":
		if e.complexity.Player.ScoreAtt == nil {
			break
		}

		return e.complexity.Player.ScoreAtt(childComplexity), true

	case "Player.scoreDef":
		if e.complexity.Player.ScoreDef == nil {
			break
		}

		return e.complexity.Player.ScoreDef(childComplexity), true

	case "Player.scoreSup":
		if e.complexity.Player.ScoreSup == nil {
			break
		}

		return e.complexity.Player.ScoreSup(childComplexity), true

	case "Player.scoreTotal":
		if e.complexity.Player.ScoreTotal == nil {
			break
		}

		return e.complexity.Player.ScoreTotal(childComplexity), true

	case "Player.servers":
		if e.complexity.Player.Servers == nil {
			break
		}

		return e.complexity.Player.Servers(childComplexity), true

	case "Player.totalVillages":
		if e.complexity.Player.TotalVillages == nil {
			break
		}

		return e.complexity.Player.TotalVillages(childComplexity), true

	case "Player.tribe":
		if e.complexity.Player.Tribe == nil {
			break
		}

		return e.complexity.Player.Tribe(childComplexity), true

	case "PlayerHistory.items":
		if e.complexity.PlayerHistory.Items == nil {
			break
		}

		return e.complexity.PlayerHistory.Items(childComplexity), true

	case "PlayerHistory.total":
		if e.complexity.PlayerHistory.Total == nil {
			break
		}

		return e.complexity.PlayerHistory.Total(childComplexity), true

	case "PlayerHistoryRecord.createDate":
		if e.complexity.PlayerHistoryRecord.CreateDate == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.CreateDate(childComplexity), true

	case "PlayerHistoryRecord.player":
		if e.complexity.PlayerHistoryRecord.Player == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.Player(childComplexity), true

	case "PlayerHistoryRecord.points":
		if e.complexity.PlayerHistoryRecord.Points == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.Points(childComplexity), true

	case "PlayerHistoryRecord.rank":
		if e.complexity.PlayerHistoryRecord.Rank == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.Rank(childComplexity), true

	case "PlayerHistoryRecord.rankAtt":
		if e.complexity.PlayerHistoryRecord.RankAtt == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.RankAtt(childComplexity), true

	case "PlayerHistoryRecord.rankDef":
		if e.complexity.PlayerHistoryRecord.RankDef == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.RankDef(childComplexity), true

	case "PlayerHistoryRecord.rankSup":
		if e.complexity.PlayerHistoryRecord.RankSup == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.RankSup(childComplexity), true

	case "PlayerHistoryRecord.rankTotal":
		if e.complexity.PlayerHistoryRecord.RankTotal == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.RankTotal(childComplexity), true

	case "PlayerHistoryRecord.scoreAtt":
		if e.complexity.PlayerHistoryRecord.ScoreAtt == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.ScoreAtt(childComplexity), true

	case "PlayerHistoryRecord.scoreDef":
		if e.complexity.PlayerHistoryRecord.ScoreDef == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.ScoreDef(childComplexity), true

	case "PlayerHistoryRecord.scoreSup":
		if e.complexity.PlayerHistoryRecord.ScoreSup == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.ScoreSup(childComplexity), true

	case "PlayerHistoryRecord.scoreTotal":
		if e.complexity.PlayerHistoryRecord.ScoreTotal == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.ScoreTotal(childComplexity), true

	case "PlayerHistoryRecord.totalVillages":
		if e.complexity.PlayerHistoryRecord.TotalVillages == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.TotalVillages(childComplexity), true

	case "PlayerHistoryRecord.tribe":
		if e.complexity.PlayerHistoryRecord.Tribe == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.Tribe(childComplexity), true

	case "PlayerList.items":
		if e.complexity.PlayerList.Items == nil {
			break
		}

		return e.complexity.PlayerList.Items(childComplexity), true

	case "PlayerList.total":
		if e.complexity.PlayerList.Total == nil {
			break
		}

		return e.complexity.PlayerList.Total(childComplexity), true

	case "PlayerNameChange.changeDate":
		if e.complexity.PlayerNameChange.ChangeDate == nil {
			break
		}

		return e.complexity.PlayerNameChange.ChangeDate(childComplexity), true

	case "PlayerNameChange.newName":
		if e.complexity.PlayerNameChange.NewName == nil {
			break
		}

		return e.complexity.PlayerNameChange.NewName(childComplexity), true

	case "PlayerNameChange.oldName":
		if e.complexity.PlayerNameChange.OldName == nil {
			break
		}

		return e.complexity.PlayerNameChange.OldName(childComplexity), true

	case "Query.dailyPlayerStats":
		if e.complexity.Query.DailyPlayerStats == nil {
			break
		}

		args, err := ec.field_Query_dailyPlayerStats_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.DailyPlayerStats(childComplexity, args["server"].(string), args["filter"].(*models.DailyPlayerStatsFilter)), true

	case "Query.dailyTribeStats":
		if e.complexity.Query.DailyTribeStats == nil {
			break
		}

		args, err := ec.field_Query_dailyTribeStats_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.DailyTribeStats(childComplexity, args["server"].(string), args["filter"].(*models.DailyTribeStatsFilter)), true

	case "Query.ennoblements":
		if e.complexity.Query.Ennoblements == nil {
			break
		}

		args, err := ec.field_Query_ennoblements_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Ennoblements(childComplexity, args["server"].(string), args["filter"].(*models.EnnoblementFilter)), true

	case "Query.langVersion":
		if e.complexity.Query.LangVersion == nil {
			break
		}

		args, err := ec.field_Query_langVersion_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.LangVersion(childComplexity, args["tag"].(models.LanguageTag)), true

	case "Query.langVersions":
		if e.complexity.Query.LangVersions == nil {
			break
		}

		args, err := ec.field_Query_langVersions_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.LangVersions(childComplexity, args["filter"].(*models.LangVersionFilter)), true

	case "Query.liveEnnoblements":
		if e.complexity.Query.LiveEnnoblements == nil {
			break
		}

		args, err := ec.field_Query_liveEnnoblements_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.LiveEnnoblements(childComplexity, args["server"].(string)), true

	case "Query.player":
		if e.complexity.Query.Player == nil {
			break
		}

		args, err := ec.field_Query_player_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Player(childComplexity, args["server"].(string), args["id"].(int)), true

	case "Query.playerHistory":
		if e.complexity.Query.PlayerHistory == nil {
			break
		}

		args, err := ec.field_Query_playerHistory_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.PlayerHistory(childComplexity, args["server"].(string), args["filter"].(*models.PlayerHistoryFilter)), true

	case "Query.players":
		if e.complexity.Query.Players == nil {
			break
		}

		args, err := ec.field_Query_players_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Players(childComplexity, args["server"].(string), args["filter"].(*models.PlayerFilter)), true

	case "Query.server":
		if e.complexity.Query.Server == nil {
			break
		}

		args, err := ec.field_Query_server_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Server(childComplexity, args["key"].(string)), true

	case "Query.serverStats":
		if e.complexity.Query.ServerStats == nil {
			break
		}

		args, err := ec.field_Query_serverStats_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.ServerStats(childComplexity, args["server"].(string), args["filter"].(*models.ServerStatsFilter)), true

	case "Query.servers":
		if e.complexity.Query.Servers == nil {
			break
		}

		args, err := ec.field_Query_servers_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Servers(childComplexity, args["filter"].(*models.ServerFilter)), true

	case "Query.tribe":
		if e.complexity.Query.Tribe == nil {
			break
		}

		args, err := ec.field_Query_tribe_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Tribe(childComplexity, args["server"].(string), args["id"].(int)), true

	case "Query.tribeChanges":
		if e.complexity.Query.TribeChanges == nil {
			break
		}

		args, err := ec.field_Query_tribeChanges_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.TribeChanges(childComplexity, args["server"].(string), args["filter"].(*models.TribeChangeFilter)), true

	case "Query.tribeHistory":
		if e.complexity.Query.TribeHistory == nil {
			break
		}

		args, err := ec.field_Query_tribeHistory_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.TribeHistory(childComplexity, args["server"].(string), args["filter"].(*models.TribeHistoryFilter)), true

	case "Query.tribes":
		if e.complexity.Query.Tribes == nil {
			break
		}

		args, err := ec.field_Query_tribes_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Tribes(childComplexity, args["server"].(string), args["filter"].(*models.TribeFilter)), true

	case "Query.village":
		if e.complexity.Query.Village == nil {
			break
		}

		args, err := ec.field_Query_village_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Village(childComplexity, args["server"].(string), args["id"].(int)), true

	case "Query.villages":
		if e.complexity.Query.Villages == nil {
			break
		}

		args, err := ec.field_Query_villages_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Villages(childComplexity, args["server"].(string), args["filter"].(*models.VillageFilter)), true

	case "Server.buildingConfig":
		if e.complexity.Server.BuildingConfig == nil {
			break
		}

		return e.complexity.Server.BuildingConfig(childComplexity), true

	case "Server.config":
		if e.complexity.Server.Config == nil {
			break
		}

		return e.complexity.Server.Config(childComplexity), true

	case "Server.dataUpdatedAt":
		if e.complexity.Server.DataUpdatedAt == nil {
			break
		}

		return e.complexity.Server.DataUpdatedAt(childComplexity), true

	case "Server.historyUpdatedAt":
		if e.complexity.Server.HistoryUpdatedAt == nil {
			break
		}

		return e.complexity.Server.HistoryUpdatedAt(childComplexity), true

	case "Server.key":
		if e.complexity.Server.Key == nil {
			break
		}

		return e.complexity.Server.Key(childComplexity), true

	case "Server.langVersion":
		if e.complexity.Server.LangVersion == nil {
			break
		}

		return e.complexity.Server.LangVersion(childComplexity), true

	case "Server.numberOfPlayers":
		if e.complexity.Server.NumberOfPlayers == nil {
			break
		}

		return e.complexity.Server.NumberOfPlayers(childComplexity), true

	case "Server.numberOfTribes":
		if e.complexity.Server.NumberOfTribes == nil {
			break
		}

		return e.complexity.Server.NumberOfTribes(childComplexity), true

	case "Server.numberOfVillages":
		if e.complexity.Server.NumberOfVillages == nil {
			break
		}

		return e.complexity.Server.NumberOfVillages(childComplexity), true

	case "Server.statsUpdatedAt":
		if e.complexity.Server.StatsUpdatedAt == nil {
			break
		}

		return e.complexity.Server.StatsUpdatedAt(childComplexity), true

	case "Server.status":
		if e.complexity.Server.Status == nil {
			break
		}

		return e.complexity.Server.Status(childComplexity), true

	case "Server.unitConfig":
		if e.complexity.Server.UnitConfig == nil {
			break
		}

		return e.complexity.Server.UnitConfig(childComplexity), true

	case "ServerConfig.ally":
		if e.complexity.ServerConfig.Ally == nil {
			break
		}

		return e.complexity.ServerConfig.Ally(childComplexity), true

	case "ServerConfig.build":
		if e.complexity.ServerConfig.Build == nil {
			break
		}

		return e.complexity.ServerConfig.Build(childComplexity), true

	case "ServerConfig.buildings":
		if e.complexity.ServerConfig.Buildings == nil {
			break
		}

		return e.complexity.ServerConfig.Buildings(childComplexity), true

	case "ServerConfig.commands":
		if e.complexity.ServerConfig.Commands == nil {
			break
		}

		return e.complexity.ServerConfig.Commands(childComplexity), true

	case "ServerConfig.coord":
		if e.complexity.ServerConfig.Coord == nil {
			break
		}

		return e.complexity.ServerConfig.Coord(childComplexity), true

	case "ServerConfig.game":
		if e.complexity.ServerConfig.Game == nil {
			break
		}

		return e.complexity.ServerConfig.Game(childComplexity), true

	case "ServerConfig.misc":
		if e.complexity.ServerConfig.Misc == nil {
			break
		}

		return e.complexity.ServerConfig.Misc(childComplexity), true

	case "ServerConfig.moral":
		if e.complexity.ServerConfig.Moral == nil {
			break
		}

		return e.complexity.ServerConfig.Moral(childComplexity), true

	case "ServerConfig.newbie":
		if e.complexity.ServerConfig.Newbie == nil {
			break
		}

		return e.complexity.ServerConfig.Newbie(childComplexity), true

	case "ServerConfig.night":
		if e.complexity.ServerConfig.Night == nil {
			break
		}

		return e.complexity.ServerConfig.Night(childComplexity), true

	case "ServerConfig.sitter":
		if e.complexity.ServerConfig.Sitter == nil {
			break
		}

		return e.complexity.ServerConfig.Sitter(childComplexity), true

	case "ServerConfig.sleep":
		if e.complexity.ServerConfig.Sleep == nil {
			break
		}

		return e.complexity.ServerConfig.Sleep(childComplexity), true

	case "ServerConfig.snob":
		if e.complexity.ServerConfig.Snob == nil {
			break
		}

		return e.complexity.ServerConfig.Snob(childComplexity), true

	case "ServerConfig.speed":
		if e.complexity.ServerConfig.Speed == nil {
			break
		}

		return e.complexity.ServerConfig.Speed(childComplexity), true

	case "ServerConfig.unitSpeed":
		if e.complexity.ServerConfig.UnitSpeed == nil {
			break
		}

		return e.complexity.ServerConfig.UnitSpeed(childComplexity), true

	case "ServerConfig.win":
		if e.complexity.ServerConfig.Win == nil {
			break
		}

		return e.complexity.ServerConfig.Win(childComplexity), true

	case "ServerConfigAlly.allytimeSupport":
		if e.complexity.ServerConfigAlly.AllytimeSupport == nil {
			break
		}

		return e.complexity.ServerConfigAlly.AllytimeSupport(childComplexity), true

	case "ServerConfigAlly.fixedAllies":
		if e.complexity.ServerConfigAlly.FixedAllies == nil {
			break
		}

		return e.complexity.ServerConfigAlly.FixedAllies(childComplexity), true

	case "ServerConfigAlly.levels":
		if e.complexity.ServerConfigAlly.Levels == nil {
			break
		}

		return e.complexity.ServerConfigAlly.Levels(childComplexity), true

	case "ServerConfigAlly.limit":
		if e.complexity.ServerConfigAlly.Limit == nil {
			break
		}

		return e.complexity.ServerConfigAlly.Limit(childComplexity), true

	case "ServerConfigAlly.noHarm":
		if e.complexity.ServerConfigAlly.NoHarm == nil {
			break
		}

		return e.complexity.ServerConfigAlly.NoHarm(childComplexity), true

	case "ServerConfigAlly.noJoin":
		if e.complexity.ServerConfigAlly.NoJoin == nil {
			break
		}

		return e.complexity.ServerConfigAlly.NoJoin(childComplexity), true

	case "ServerConfigAlly.noLeave":
		if e.complexity.ServerConfigAlly.NoLeave == nil {
			break
		}

		return e.complexity.ServerConfigAlly.NoLeave(childComplexity), true

	case "ServerConfigAlly.noOtherSupport":
		if e.complexity.ServerConfigAlly.NoOtherSupport == nil {
			break
		}

		return e.complexity.ServerConfigAlly.NoOtherSupport(childComplexity), true

	case "ServerConfigAlly.pointsMemberCount":
		if e.complexity.ServerConfigAlly.PointsMemberCount == nil {
			break
		}

		return e.complexity.ServerConfigAlly.PointsMemberCount(childComplexity), true

	case "ServerConfigAlly.warsAutoacceptDays":
		if e.complexity.ServerConfigAlly.WarsAutoacceptDays == nil {
			break
		}

		return e.complexity.ServerConfigAlly.WarsAutoacceptDays(childComplexity), true

	case "ServerConfigAlly.warsMemberRequirement":
		if e.complexity.ServerConfigAlly.WarsMemberRequirement == nil {
			break
		}

		return e.complexity.ServerConfigAlly.WarsMemberRequirement(childComplexity), true

	case "ServerConfigAlly.warsPointsRequirement":
		if e.complexity.ServerConfigAlly.WarsPointsRequirement == nil {
			break
		}

		return e.complexity.ServerConfigAlly.WarsPointsRequirement(childComplexity), true

	case "ServerConfigAlly.xpRequirements":
		if e.complexity.ServerConfigAlly.XpRequirements == nil {
			break
		}

		return e.complexity.ServerConfigAlly.XpRequirements(childComplexity), true

	case "ServerConfigBuild.destroy":
		if e.complexity.ServerConfigBuild.Destroy == nil {
			break
		}

		return e.complexity.ServerConfigBuild.Destroy(childComplexity), true

	case "ServerConfigBuildings.customBarracks":
		if e.complexity.ServerConfigBuildings.CustomBarracks == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomBarracks(childComplexity), true

	case "ServerConfigBuildings.customChurch":
		if e.complexity.ServerConfigBuildings.CustomChurch == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomChurch(childComplexity), true

	case "ServerConfigBuildings.customFarm":
		if e.complexity.ServerConfigBuildings.CustomFarm == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomFarm(childComplexity), true

	case "ServerConfigBuildings.customGarage":
		if e.complexity.ServerConfigBuildings.CustomGarage == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomGarage(childComplexity), true

	case "ServerConfigBuildings.customHide":
		if e.complexity.ServerConfigBuildings.CustomHide == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomHide(childComplexity), true

	case "ServerConfigBuildings.customIron":
		if e.complexity.ServerConfigBuildings.CustomIron == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomIron(childComplexity), true

	case "ServerConfigBuildings.customMain":
		if e.complexity.ServerConfigBuildings.CustomMain == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomMain(childComplexity), true

	case "ServerConfigBuildings.customMarket":
		if e.complexity.ServerConfigBuildings.CustomMarket == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomMarket(childComplexity), true

	case "ServerConfigBuildings.customPlace":
		if e.complexity.ServerConfigBuildings.CustomPlace == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomPlace(childComplexity), true

	case "ServerConfigBuildings.customSmith":
		if e.complexity.ServerConfigBuildings.CustomSmith == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomSmith(childComplexity), true

	case "ServerConfigBuildings.customSnob":
		if e.complexity.ServerConfigBuildings.CustomSnob == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomSnob(childComplexity), true

	case "ServerConfigBuildings.customStable":
		if e.complexity.ServerConfigBuildings.CustomStable == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomStable(childComplexity), true

	case "ServerConfigBuildings.customStatue":
		if e.complexity.ServerConfigBuildings.CustomStatue == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomStatue(childComplexity), true

	case "ServerConfigBuildings.customStone":
		if e.complexity.ServerConfigBuildings.CustomStone == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomStone(childComplexity), true

	case "ServerConfigBuildings.customStorage":
		if e.complexity.ServerConfigBuildings.CustomStorage == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomStorage(childComplexity), true

	case "ServerConfigBuildings.customWall":
		if e.complexity.ServerConfigBuildings.CustomWall == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomWall(childComplexity), true

	case "ServerConfigBuildings.customWatchtower":
		if e.complexity.ServerConfigBuildings.CustomWatchtower == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomWatchtower(childComplexity), true

	case "ServerConfigBuildings.customWood":
		if e.complexity.ServerConfigBuildings.CustomWood == nil {
			break
		}

		return e.complexity.ServerConfigBuildings.CustomWood(childComplexity), true

	case "ServerConfigCommands.commandCancelTime":
		if e.complexity.ServerConfigCommands.CommandCancelTime == nil {
			break
		}

		return e.complexity.ServerConfigCommands.CommandCancelTime(childComplexity), true

	case "ServerConfigCommands.millisArrival":
		if e.complexity.ServerConfigCommands.MillisArrival == nil {
			break
		}

		return e.complexity.ServerConfigCommands.MillisArrival(childComplexity), true

	case "ServerConfigCoord.bonusNew":
		if e.complexity.ServerConfigCoord.BonusNew == nil {
			break
		}

		return e.complexity.ServerConfigCoord.BonusNew(childComplexity), true

	case "ServerConfigCoord.bonusVillages":
		if e.complexity.ServerConfigCoord.BonusVillages == nil {
			break
		}

		return e.complexity.ServerConfigCoord.BonusVillages(childComplexity), true

	case "ServerConfigCoord.emptyVillages":
		if e.complexity.ServerConfigCoord.EmptyVillages == nil {
			break
		}

		return e.complexity.ServerConfigCoord.EmptyVillages(childComplexity), true

	case "ServerConfigCoord.func":
		if e.complexity.ServerConfigCoord.Func == nil {
			break
		}

		return e.complexity.ServerConfigCoord.Func(childComplexity), true

	case "ServerConfigCoord.inner":
		if e.complexity.ServerConfigCoord.Inner == nil {
			break
		}

		return e.complexity.ServerConfigCoord.Inner(childComplexity), true

	case "ServerConfigCoord.mapSize":
		if e.complexity.ServerConfigCoord.MapSize == nil {
			break
		}

		return e.complexity.ServerConfigCoord.MapSize(childComplexity), true

	case "ServerConfigCoord.nobleRestart":
		if e.complexity.ServerConfigCoord.NobleRestart == nil {
			break
		}

		return e.complexity.ServerConfigCoord.NobleRestart(childComplexity), true

	case "ServerConfigCoord.selectStart":
		if e.complexity.ServerConfigCoord.SelectStart == nil {
			break
		}

		return e.complexity.ServerConfigCoord.SelectStart(childComplexity), true

	case "ServerConfigCoord.startVillages":
		if e.complexity.ServerConfigCoord.StartVillages == nil {
			break
		}

		return e.complexity.ServerConfigCoord.StartVillages(childComplexity), true

	case "ServerConfigCoord.villageMoveWait":
		if e.complexity.ServerConfigCoord.VillageMoveWait == nil {
			break
		}

		return e.complexity.ServerConfigCoord.VillageMoveWait(childComplexity), true

	case "ServerConfigGame.archer":
		if e.complexity.ServerConfigGame.Archer == nil {
			break
		}

		return e.complexity.ServerConfigGame.Archer(childComplexity), true

	case "ServerConfigGame.barbarianMaxPoints":
		if e.complexity.ServerConfigGame.BarbarianMaxPoints == nil {
			break
		}

		return e.complexity.ServerConfigGame.BarbarianMaxPoints(childComplexity), true

	case "ServerConfigGame.barbarianRise":
		if e.complexity.ServerConfigGame.BarbarianRise == nil {
			break
		}

		return e.complexity.ServerConfigGame.BarbarianRise(childComplexity), true

	case "ServerConfigGame.barbarianShrink":
		if e.complexity.ServerConfigGame.BarbarianShrink == nil {
			break
		}

		return e.complexity.ServerConfigGame.BarbarianShrink(childComplexity), true

	case "ServerConfigGame.baseProduction":
		if e.complexity.ServerConfigGame.BaseProduction == nil {
			break
		}

		return e.complexity.ServerConfigGame.BaseProduction(childComplexity), true

	case "ServerConfigGame.buildtimeFormula":
		if e.complexity.ServerConfigGame.BuildtimeFormula == nil {
			break
		}

		return e.complexity.ServerConfigGame.BuildtimeFormula(childComplexity), true

	case "ServerConfigGame.church":
		if e.complexity.ServerConfigGame.Church == nil {
			break
		}

		return e.complexity.ServerConfigGame.Church(childComplexity), true

	case "ServerConfigGame.event":
		if e.complexity.ServerConfigGame.Event == nil {
			break
		}

		return e.complexity.ServerConfigGame.Event(childComplexity), true

	case "ServerConfigGame.fakeLimit":
		if e.complexity.ServerConfigGame.FakeLimit == nil {
			break
		}

		return e.complexity.ServerConfigGame.FakeLimit(childComplexity), true

	case "ServerConfigGame.farmLimit":
		if e.complexity.ServerConfigGame.FarmLimit == nil {
			break
		}

		return e.complexity.ServerConfigGame.FarmLimit(childComplexity), true

	case "ServerConfigGame.hauls":
		if e.complexity.ServerConfigGame.Hauls == nil {
			break
		}

		return e.complexity.ServerConfigGame.Hauls(childComplexity), true

	case "ServerConfigGame.haulsBase":
		if e.complexity.ServerConfigGame.HaulsBase == nil {
			break
		}

		return e.complexity.ServerConfigGame.HaulsBase(childComplexity), true

	case "ServerConfigGame.haulsMax":
		if e.complexity.ServerConfigGame.HaulsMax == nil {
			break
		}

		return e.complexity.ServerConfigGame.HaulsMax(childComplexity), true

	case "ServerConfigGame.knight":
		if e.complexity.ServerConfigGame.Knight == nil {
			break
		}

		return e.complexity.ServerConfigGame.Knight(childComplexity), true

	case "ServerConfigGame.knightNewItems":
		if e.complexity.ServerConfigGame.KnightNewItems == nil {
			break
		}

		return e.complexity.ServerConfigGame.KnightNewItems(childComplexity), true

	case "ServerConfigGame.stronghold":
		if e.complexity.ServerConfigGame.Stronghold == nil {
			break
		}

		return e.complexity.ServerConfigGame.Stronghold(childComplexity), true

	case "ServerConfigGame.suppressEvents":
		if e.complexity.ServerConfigGame.SuppressEvents == nil {
			break
		}

		return e.complexity.ServerConfigGame.SuppressEvents(childComplexity), true

	case "ServerConfigGame.tech":
		if e.complexity.ServerConfigGame.Tech == nil {
			break
		}

		return e.complexity.ServerConfigGame.Tech(childComplexity), true

	case "ServerConfigGame.watchtower":
		if e.complexity.ServerConfigGame.Watchtower == nil {
			break
		}

		return e.complexity.ServerConfigGame.Watchtower(childComplexity), true

	case "ServerConfigMisc.killRanking":
		if e.complexity.ServerConfigMisc.KillRanking == nil {
			break
		}

		return e.complexity.ServerConfigMisc.KillRanking(childComplexity), true

	case "ServerConfigMisc.tradeCancelTime":
		if e.complexity.ServerConfigMisc.TradeCancelTime == nil {
			break
		}

		return e.complexity.ServerConfigMisc.TradeCancelTime(childComplexity), true

	case "ServerConfigMisc.tutorial":
		if e.complexity.ServerConfigMisc.Tutorial == nil {
			break
		}

		return e.complexity.ServerConfigMisc.Tutorial(childComplexity), true

	case "ServerConfigNewbie.days":
		if e.complexity.ServerConfigNewbie.Days == nil {
			break
		}

		return e.complexity.ServerConfigNewbie.Days(childComplexity), true

	case "ServerConfigNewbie.ratio":
		if e.complexity.ServerConfigNewbie.Ratio == nil {
			break
		}

		return e.complexity.ServerConfigNewbie.Ratio(childComplexity), true

	case "ServerConfigNewbie.ratioDays":
		if e.complexity.ServerConfigNewbie.RatioDays == nil {
			break
		}

		return e.complexity.ServerConfigNewbie.RatioDays(childComplexity), true

	case "ServerConfigNewbie.removeNewbieVillages":
		if e.complexity.ServerConfigNewbie.RemoveNewbieVillages == nil {
			break
		}

		return e.complexity.ServerConfigNewbie.RemoveNewbieVillages(childComplexity), true

	case "ServerConfigNight.active":
		if e.complexity.ServerConfigNight.Active == nil {
			break
		}

		return e.complexity.ServerConfigNight.Active(childComplexity), true

	case "ServerConfigNight.defFactor":
		if e.complexity.ServerConfigNight.DefFactor == nil {
			break
		}

		return e.complexity.ServerConfigNight.DefFactor(childComplexity), true

	case "ServerConfigNight.endHour":
		if e.complexity.ServerConfigNight.EndHour == nil {
			break
		}

		return e.complexity.ServerConfigNight.EndHour(childComplexity), true

	case "ServerConfigNight.startHour":
		if e.complexity.ServerConfigNight.StartHour == nil {
			break
		}

		return e.complexity.ServerConfigNight.StartHour(childComplexity), true

	case "ServerConfigSitter.allow":
		if e.complexity.ServerConfigSitter.Allow == nil {
			break
		}

		return e.complexity.ServerConfigSitter.Allow(childComplexity), true

	case "ServerConfigSleep.active":
		if e.complexity.ServerConfigSleep.Active == nil {
			break
		}

		return e.complexity.ServerConfigSleep.Active(childComplexity), true

	case "ServerConfigSleep.delay":
		if e.complexity.ServerConfigSleep.Delay == nil {
			break
		}

		return e.complexity.ServerConfigSleep.Delay(childComplexity), true

	case "ServerConfigSleep.max":
		if e.complexity.ServerConfigSleep.Max == nil {
			break
		}

		return e.complexity.ServerConfigSleep.Max(childComplexity), true

	case "ServerConfigSleep.maxAwake":
		if e.complexity.ServerConfigSleep.MaxAwake == nil {
			break
		}

		return e.complexity.ServerConfigSleep.MaxAwake(childComplexity), true

	case "ServerConfigSleep.min":
		if e.complexity.ServerConfigSleep.Min == nil {
			break
		}

		return e.complexity.ServerConfigSleep.Min(childComplexity), true

	case "ServerConfigSleep.minAwake":
		if e.complexity.ServerConfigSleep.MinAwake == nil {
			break
		}

		return e.complexity.ServerConfigSleep.MinAwake(childComplexity), true

	case "ServerConfigSleep.warnTime":
		if e.complexity.ServerConfigSleep.WarnTime == nil {
			break
		}

		return e.complexity.ServerConfigSleep.WarnTime(childComplexity), true

	case "ServerConfigSnob.cheapRebuild":
		if e.complexity.ServerConfigSnob.CheapRebuild == nil {
			break
		}

		return e.complexity.ServerConfigSnob.CheapRebuild(childComplexity), true

	case "ServerConfigSnob.coinIron":
		if e.complexity.ServerConfigSnob.CoinIron == nil {
			break
		}

		return e.complexity.ServerConfigSnob.CoinIron(childComplexity), true

	case "ServerConfigSnob.coinStone":
		if e.complexity.ServerConfigSnob.CoinStone == nil {
			break
		}

		return e.complexity.ServerConfigSnob.CoinStone(childComplexity), true

	case "ServerConfigSnob.coinWood":
		if e.complexity.ServerConfigSnob.CoinWood == nil {
			break
		}

		return e.complexity.ServerConfigSnob.CoinWood(childComplexity), true

	case "ServerConfigSnob.factor":
		if e.complexity.ServerConfigSnob.Factor == nil {
			break
		}

		return e.complexity.ServerConfigSnob.Factor(childComplexity), true

	case "ServerConfigSnob.gold":
		if e.complexity.ServerConfigSnob.Gold == nil {
			break
		}

		return e.complexity.ServerConfigSnob.Gold(childComplexity), true

	case "ServerConfigSnob.maxDist":
		if e.complexity.ServerConfigSnob.MaxDist == nil {
			break
		}

		return e.complexity.ServerConfigSnob.MaxDist(childComplexity), true

	case "ServerConfigSnob.noBarbConquer":
		if e.complexity.ServerConfigSnob.NoBarbConquer == nil {
			break
		}

		return e.complexity.ServerConfigSnob.NoBarbConquer(childComplexity), true

	case "ServerConfigSnob.rise":
		if e.complexity.ServerConfigSnob.Rise == nil {
			break
		}

		return e.complexity.ServerConfigSnob.Rise(childComplexity), true

	case "ServerConfigWin.check":
		if e.complexity.ServerConfigWin.Check == nil {
			break
		}

		return e.complexity.ServerConfigWin.Check(childComplexity), true

	case "ServerList.items":
		if e.complexity.ServerList.Items == nil {
			break
		}

		return e.complexity.ServerList.Items(childComplexity), true

	case "ServerList.total":
		if e.complexity.ServerList.Total == nil {
			break
		}

		return e.complexity.ServerList.Total(childComplexity), true

	case "ServerStats.items":
		if e.complexity.ServerStats.Items == nil {
			break
		}

		return e.complexity.ServerStats.Items(childComplexity), true

	case "ServerStats.total":
		if e.complexity.ServerStats.Total == nil {
			break
		}

		return e.complexity.ServerStats.Total(childComplexity), true

	case "ServerStatsRecord.activePlayers":
		if e.complexity.ServerStatsRecord.ActivePlayers == nil {
			break
		}

		return e.complexity.ServerStatsRecord.ActivePlayers(childComplexity), true

	case "ServerStatsRecord.activeTribes":
		if e.complexity.ServerStatsRecord.ActiveTribes == nil {
			break
		}

		return e.complexity.ServerStatsRecord.ActiveTribes(childComplexity), true

	case "ServerStatsRecord.barbarianVillages":
		if e.complexity.ServerStatsRecord.BarbarianVillages == nil {
			break
		}

		return e.complexity.ServerStatsRecord.BarbarianVillages(childComplexity), true

	case "ServerStatsRecord.bonusVillages":
		if e.complexity.ServerStatsRecord.BonusVillages == nil {
			break
		}

		return e.complexity.ServerStatsRecord.BonusVillages(childComplexity), true

	case "ServerStatsRecord.createDate":
		if e.complexity.ServerStatsRecord.CreateDate == nil {
			break
		}

		return e.complexity.ServerStatsRecord.CreateDate(childComplexity), true

	case "ServerStatsRecord.inactivePlayers":
		if e.complexity.ServerStatsRecord.InactivePlayers == nil {
			break
		}

		return e.complexity.ServerStatsRecord.InactivePlayers(childComplexity), true

	case "ServerStatsRecord.inactiveTribes":
		if e.complexity.ServerStatsRecord.InactiveTribes == nil {
			break
		}

		return e.complexity.ServerStatsRecord.InactiveTribes(childComplexity), true

	case "ServerStatsRecord.playerVillages":
		if e.complexity.ServerStatsRecord.PlayerVillages == nil {
			break
		}

		return e.complexity.ServerStatsRecord.PlayerVillages(childComplexity), true

	case "ServerStatsRecord.players":
		if e.complexity.ServerStatsRecord.Players == nil {
			break
		}

		return e.complexity.ServerStatsRecord.Players(childComplexity), true

	case "ServerStatsRecord.tribes":
		if e.complexity.ServerStatsRecord.Tribes == nil {
			break
		}

		return e.complexity.ServerStatsRecord.Tribes(childComplexity), true

	case "ServerStatsRecord.villages":
		if e.complexity.ServerStatsRecord.Villages == nil {
			break
		}

		return e.complexity.ServerStatsRecord.Villages(childComplexity), true

	case "Tribe.allPoints":
		if e.complexity.Tribe.AllPoints == nil {
			break
		}

		return e.complexity.Tribe.AllPoints(childComplexity), true

	case "Tribe.bestRank":
		if e.complexity.Tribe.BestRank == nil {
			break
		}

		return e.complexity.Tribe.BestRank(childComplexity), true

	case "Tribe.bestRankAt":
		if e.complexity.Tribe.BestRankAt == nil {
			break
		}

		return e.complexity.Tribe.BestRankAt(childComplexity), true

	case "Tribe.createdAt":
		if e.complexity.Tribe.CreatedAt == nil {
			break
		}

		return e.complexity.Tribe.CreatedAt(childComplexity), true

	case "Tribe.deletedAt":
		if e.complexity.Tribe.DeletedAt == nil {
			break
		}

		return e.complexity.Tribe.DeletedAt(childComplexity), true

	case "Tribe.dominance":
		if e.complexity.Tribe.Dominance == nil {
			break
		}

		return e.complexity.Tribe.Dominance(childComplexity), true

	case "Tribe.exists":
		if e.complexity.Tribe.Exists == nil {
			break
		}

		return e.complexity.Tribe.Exists(childComplexity), true

	case "Tribe.id":
		if e.complexity.Tribe.ID == nil {
			break
		}

		return e.complexity.Tribe.ID(childComplexity), true

	case "Tribe.mostPoints":
		if e.complexity.Tribe.MostPoints == nil {
			break
		}

		return e.complexity.Tribe.MostPoints(childComplexity), true

	case "Tribe.mostPointsAt":
		if e.complexity.Tribe.MostPointsAt == nil {
			break
		}

		return e.complexity.Tribe.MostPointsAt(childComplexity), true

	case "Tribe.mostVillages":
		if e.complexity.Tribe.MostVillages == nil {
			break
		}

		return e.complexity.Tribe.MostVillages(childComplexity), true

	case "Tribe.mostVillagesAt":
		if e.complexity.Tribe.MostVillagesAt == nil {
			break
		}

		return e.complexity.Tribe.MostVillagesAt(childComplexity), true

	case "Tribe.name":
		if e.complexity.Tribe.Name == nil {
			break
		}

		return e.complexity.Tribe.Name(childComplexity), true

	case "Tribe.points":
		if e.complexity.Tribe.Points == nil {
			break
		}

		return e.complexity.Tribe.Points(childComplexity), true

	case "Tribe.rank":
		if e.complexity.Tribe.Rank == nil {
			break
		}

		return e.complexity.Tribe.Rank(childComplexity), true

	case "Tribe.rankAtt":
		if e.complexity.Tribe.RankAtt == nil {
			break
		}

		return e.complexity.Tribe.RankAtt(childComplexity), true

	case "Tribe.rankDef":
		if e.complexity.Tribe.RankDef == nil {
			break
		}

		return e.complexity.Tribe.RankDef(childComplexity), true

	case "Tribe.rankTotal":
		if e.complexity.Tribe.RankTotal == nil {
			break
		}

		return e.complexity.Tribe.RankTotal(childComplexity), true

	case "Tribe.scoreAtt":
		if e.complexity.Tribe.ScoreAtt == nil {
			break
		}

		return e.complexity.Tribe.ScoreAtt(childComplexity), true

	case "Tribe.scoreDef":
		if e.complexity.Tribe.ScoreDef == nil {
			break
		}

		return e.complexity.Tribe.ScoreDef(childComplexity), true

	case "Tribe.scoreTotal":
		if e.complexity.Tribe.ScoreTotal == nil {
			break
		}

		return e.complexity.Tribe.ScoreTotal(childComplexity), true

	case "Tribe.tag":
		if e.complexity.Tribe.Tag == nil {
			break
		}

		return e.complexity.Tribe.Tag(childComplexity), true

	case "Tribe.totalMembers":
		if e.complexity.Tribe.TotalMembers == nil {
			break
		}

		return e.complexity.Tribe.TotalMembers(childComplexity), true

	case "Tribe.totalVillages":
		if e.complexity.Tribe.TotalVillages == nil {
			break
		}

		return e.complexity.Tribe.TotalVillages(childComplexity), true

	case "TribeChangeRecord.createdAt":
		if e.complexity.TribeChangeRecord.CreatedAt == nil {
			break
		}

		return e.complexity.TribeChangeRecord.CreatedAt(childComplexity), true

	case "TribeChangeRecord.newTribe":
		if e.complexity.TribeChangeRecord.NewTribe == nil {
			break
		}

		return e.complexity.TribeChangeRecord.NewTribe(childComplexity), true

	case "TribeChangeRecord.oldTribe":
		if e.complexity.TribeChangeRecord.OldTribe == nil {
			break
		}

		return e.complexity.TribeChangeRecord.OldTribe(childComplexity), true

	case "TribeChangeRecord.player":
		if e.complexity.TribeChangeRecord.Player == nil {
			break
		}

		return e.complexity.TribeChangeRecord.Player(childComplexity), true

	case "TribeChanges.items":
		if e.complexity.TribeChanges.Items == nil {
			break
		}

		return e.complexity.TribeChanges.Items(childComplexity), true

	case "TribeChanges.total":
		if e.complexity.TribeChanges.Total == nil {
			break
		}

		return e.complexity.TribeChanges.Total(childComplexity), true

	case "TribeHistory.items":
		if e.complexity.TribeHistory.Items == nil {
			break
		}

		return e.complexity.TribeHistory.Items(childComplexity), true

	case "TribeHistory.total":
		if e.complexity.TribeHistory.Total == nil {
			break
		}

		return e.complexity.TribeHistory.Total(childComplexity), true

	case "TribeHistoryRecord.allPoints":
		if e.complexity.TribeHistoryRecord.AllPoints == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.AllPoints(childComplexity), true

	case "TribeHistoryRecord.createDate":
		if e.complexity.TribeHistoryRecord.CreateDate == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.CreateDate(childComplexity), true

	case "TribeHistoryRecord.dominance":
		if e.complexity.TribeHistoryRecord.Dominance == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.Dominance(childComplexity), true

	case "TribeHistoryRecord.points":
		if e.complexity.TribeHistoryRecord.Points == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.Points(childComplexity), true

	case "TribeHistoryRecord.rank":
		if e.complexity.TribeHistoryRecord.Rank == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.Rank(childComplexity), true

	case "TribeHistoryRecord.rankAtt":
		if e.complexity.TribeHistoryRecord.RankAtt == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.RankAtt(childComplexity), true

	case "TribeHistoryRecord.rankDef":
		if e.complexity.TribeHistoryRecord.RankDef == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.RankDef(childComplexity), true

	case "TribeHistoryRecord.rankTotal":
		if e.complexity.TribeHistoryRecord.RankTotal == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.RankTotal(childComplexity), true

	case "TribeHistoryRecord.scoreAtt":
		if e.complexity.TribeHistoryRecord.ScoreAtt == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.ScoreAtt(childComplexity), true

	case "TribeHistoryRecord.scoreDef":
		if e.complexity.TribeHistoryRecord.ScoreDef == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.ScoreDef(childComplexity), true

	case "TribeHistoryRecord.scoreTotal":
		if e.complexity.TribeHistoryRecord.ScoreTotal == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.ScoreTotal(childComplexity), true

	case "TribeHistoryRecord.totalMembers":
		if e.complexity.TribeHistoryRecord.TotalMembers == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.TotalMembers(childComplexity), true

	case "TribeHistoryRecord.totalVillages":
		if e.complexity.TribeHistoryRecord.TotalVillages == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.TotalVillages(childComplexity), true

	case "TribeHistoryRecord.tribe":
		if e.complexity.TribeHistoryRecord.Tribe == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.Tribe(childComplexity), true

	case "TribeList.items":
		if e.complexity.TribeList.Items == nil {
			break
		}

		return e.complexity.TribeList.Items(childComplexity), true

	case "TribeList.total":
		if e.complexity.TribeList.Total == nil {
			break
		}

		return e.complexity.TribeList.Total(childComplexity), true

	case "Unit.attack":
		if e.complexity.Unit.Attack == nil {
			break
		}

		return e.complexity.Unit.Attack(childComplexity), true

	case "Unit.buildTime":
		if e.complexity.Unit.BuildTime == nil {
			break
		}

		return e.complexity.Unit.BuildTime(childComplexity), true

	case "Unit.carry":
		if e.complexity.Unit.Carry == nil {
			break
		}

		return e.complexity.Unit.Carry(childComplexity), true

	case "Unit.defense":
		if e.complexity.Unit.Defense == nil {
			break
		}

		return e.complexity.Unit.Defense(childComplexity), true

	case "Unit.defenseArcher":
		if e.complexity.Unit.DefenseArcher == nil {
			break
		}

		return e.complexity.Unit.DefenseArcher(childComplexity), true

	case "Unit.defenseCavalry":
		if e.complexity.Unit.DefenseCavalry == nil {
			break
		}

		return e.complexity.Unit.DefenseCavalry(childComplexity), true

	case "Unit.pop":
		if e.complexity.Unit.Pop == nil {
			break
		}

		return e.complexity.Unit.Pop(childComplexity), true

	case "Unit.speed":
		if e.complexity.Unit.Speed == nil {
			break
		}

		return e.complexity.Unit.Speed(childComplexity), true

	case "UnitConfig.archer":
		if e.complexity.UnitConfig.Archer == nil {
			break
		}

		return e.complexity.UnitConfig.Archer(childComplexity), true

	case "UnitConfig.axe":
		if e.complexity.UnitConfig.Axe == nil {
			break
		}

		return e.complexity.UnitConfig.Axe(childComplexity), true

	case "UnitConfig.catapult":
		if e.complexity.UnitConfig.Catapult == nil {
			break
		}

		return e.complexity.UnitConfig.Catapult(childComplexity), true

	case "UnitConfig.heavy":
		if e.complexity.UnitConfig.Heavy == nil {
			break
		}

		return e.complexity.UnitConfig.Heavy(childComplexity), true

	case "UnitConfig.knight":
		if e.complexity.UnitConfig.Knight == nil {
			break
		}

		return e.complexity.UnitConfig.Knight(childComplexity), true

	case "UnitConfig.light":
		if e.complexity.UnitConfig.Light == nil {
			break
		}

		return e.complexity.UnitConfig.Light(childComplexity), true

	case "UnitConfig.marcher":
		if e.complexity.UnitConfig.Marcher == nil {
			break
		}

		return e.complexity.UnitConfig.Marcher(childComplexity), true

	case "UnitConfig.militia":
		if e.complexity.UnitConfig.Militia == nil {
			break
		}

		return e.complexity.UnitConfig.Militia(childComplexity), true

	case "UnitConfig.ram":
		if e.complexity.UnitConfig.Ram == nil {
			break
		}

		return e.complexity.UnitConfig.Ram(childComplexity), true

	case "UnitConfig.snob":
		if e.complexity.UnitConfig.Snob == nil {
			break
		}

		return e.complexity.UnitConfig.Snob(childComplexity), true

	case "UnitConfig.spear":
		if e.complexity.UnitConfig.Spear == nil {
			break
		}

		return e.complexity.UnitConfig.Spear(childComplexity), true

	case "UnitConfig.spy":
		if e.complexity.UnitConfig.Spy == nil {
			break
		}

		return e.complexity.UnitConfig.Spy(childComplexity), true

	case "UnitConfig.sword":
		if e.complexity.UnitConfig.Sword == nil {
			break
		}

		return e.complexity.UnitConfig.Sword(childComplexity), true

	case "Village.bonus":
		if e.complexity.Village.Bonus == nil {
			break
		}

		return e.complexity.Village.Bonus(childComplexity), true

	case "Village.id":
		if e.complexity.Village.ID == nil {
			break
		}

		return e.complexity.Village.ID(childComplexity), true

	case "Village.name":
		if e.complexity.Village.Name == nil {
			break
		}

		return e.complexity.Village.Name(childComplexity), true

	case "Village.player":
		if e.complexity.Village.Player == nil {
			break
		}

		return e.complexity.Village.Player(childComplexity), true

	case "Village.points":
		if e.complexity.Village.Points == nil {
			break
		}

		return e.complexity.Village.Points(childComplexity), true

	case "Village.x":
		if e.complexity.Village.X == nil {
			break
		}

		return e.complexity.Village.X(childComplexity), true

	case "Village.y":
		if e.complexity.Village.Y == nil {
			break
		}

		return e.complexity.Village.Y(childComplexity), true

	case "VillageList.items":
		if e.complexity.VillageList.Items == nil {
			break
		}

		return e.complexity.VillageList.Items(childComplexity), true

	case "VillageList.total":
		if e.complexity.VillageList.Total == nil {
			break
		}

		return e.complexity.VillageList.Total(childComplexity), true

	}
	return 0, false
}

func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	rc := graphql.GetOperationContext(ctx)
	ec := executionContext{rc, e}
	first := true

	switch rc.Operation.Operation {
	case ast.Query:
		return func(ctx context.Context) *graphql.Response {
			if !first {
				return nil
			}
			first = false
			data := ec._Query(ctx, rc.Operation.SelectionSet)
			var buf bytes.Buffer
			data.MarshalGQL(&buf)

			return &graphql.Response{
				Data: buf.Bytes(),
			}
		}

	default:
		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
	}
}

type executionContext struct {
	*graphql.OperationContext
	*executableSchema
}

func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapSchema(parsedSchema), nil
}

func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
}

var sources = []*ast.Source{
	&ast.Source{Name: "schema/building_config.graphql", Input: `type Building {
  maxLevel: Int!
  minLevel: Int!
  wood: Int!
  stone: Int!
  iron: Int!
  pop: Int!
  woodFactor: Float!
  stoneFactor: Float!
  ironFactor: Float!
  popFactor: Float!
  buildTime: Float!
  buildTimeFactor: Float!
}

type BuildingConfig {
  main: Building!
  barracks: Building!
  stable: Building!
  garage: Building!
  watchtower: Building!
  snob: Building!
  smith: Building!
  place: Building!
  statue: Building!
  market: Building!
  wood: Building!
  stone: Building!
  iron: Building!
  farm: Building!
  storage: Building!
  hide: Building!
  wall: Building!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/daily_player_stats.graphql", Input: `type DailyPlayerStatsRecord {
  player: Player @goField(forceResolver: true)
  villages: Int!
  points: Int!
  rank: Int!
  rankAtt: Int!
  scoreAtt: Int!
  rankDef: Int!
  scoreDef: Int!
  rankSup: Int!
  scoreSup: Int!
  rankTotal: Int!
  scoreTotal: Int!
  createDate: Time!
}

type DailyPlayerStats {
  total: Int!
  items: [DailyPlayerStatsRecord!]
}

input DailyPlayerStatsFilter {
  playerID: [Int!]
  playerIDNEQ: [Int!]

  createDate: Time
  createDateGT: Time
  createDateGTE: Time
  createDateLT: Time
  createDateLTE: Time

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  dailyPlayerStats(
    server: String!
    filter: DailyPlayerStatsFilter
  ): DailyPlayerStats!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/daily_tribe_stats.graphql", Input: `type DailyTribeStatsRecord {
  tribe: Tribe @goField(forceResolver: true)
  members: Int!
  villages: Int!
  points: Int!
  allPoints: Int!
  rank: Int!
  rankAtt: Int!
  scoreAtt: Int!
  rankDef: Int!
  scoreDef: Int!
  rankTotal: Int!
  scoreTotal: Int!
  dominance: Float!
  createDate: Time!
}

type DailyTribeStats {
  total: Int!
  items: [DailyTribeStatsRecord!]
}

input DailyTribeStatsFilter {
  tribeID: [Int!]
  tribeIDNEQ: [Int!]

  createDate: Time
  createDateGT: Time
  createDateGTE: Time
  createDateLT: Time
  createDateLTE: Time

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  dailyTribeStats(
    server: String!
    filter: DailyTribeStatsFilter
  ): DailyTribeStats!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/directives.graphql", Input: `directive @goField(
  forceResolver: Boolean
  name: String
) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION
`, BuiltIn: false},
	&ast.Source{Name: "schema/ennoblements.graphql", Input: `type Ennoblement {
  village: Village @goField(forceResolver: true)
  newOwner: Player @goField(forceResolver: true)
  newOwnerTribe: Tribe @goField(forceResolver: true)
  oldOwner: Player @goField(forceResolver: true)
  oldOwnerTribe: Tribe @goField(forceResolver: true)
  ennobledAt: Time!
}

type EnnoblementList {
  items: [Ennoblement!]
  total: Int!
}

input EnnoblementFilter {
  villageID: [Int!]
  villageIDNEQ: [Int!]

  newOwnerID: [Int!]
  newOwnerIDNEQ: [Int!]
  newOwnerTribeID: [Int!]
  newOwnerTribeIDNEQ: [Int!]

  oldOwnerID: [Int!]
  oldOwnerIDNEQ: [Int!]
  oldOwnerTribeID: [Int!]
  oldOwnerTribeIDNEQ: [Int!]

  ennobledAt: Time
  ennobledAtGT: Time
  ennobledAtGTE: Time
  ennobledAtLT: Time
  ennobledAtLTE: Time

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  ennoblements(server: String!, filter: EnnoblementFilter): EnnoblementList!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/lang_version.graphql", Input: `enum LanguageTag {
  PL
  EN
  DE
}

type LangVersion {
  tag: LanguageTag!
  name: String!
  host: String!
  timezone: String!
}

input LangVersionFilter {
  tag: [LanguageTag!]
  tagNEQ: [LanguageTag!]

  host: [String!]
  hostNEQ: [String!]
  hostMATCH: String
  hostIEQ: String

  offset: Int
  limit: Int
  sort: String
}

type LangVersionList {
  items: [LangVersion!]
  total: Int!
}

extend type Query {
  langVersions(filter: LangVersionFilter): LangVersionList!
  langVersion(tag: LanguageTag!): LangVersion
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/live_ennoblement.graphql", Input: `type LiveEnnoblement {
  village: Village @goField(forceResolver: true)
  newOwner: Player @goField(forceResolver: true)
  oldOwner: Player @goField(forceResolver: true)
  ennobledAt: Time!
}

extend type Query {
  liveEnnoblements(server: String!): [LiveEnnoblement!]
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/player.graphql", Input: `type PlayerNameChange {
  oldName: String!
  newName: String!
  changeDate: Time!
}

type Player {
  id: Int!
  name: String!
  totalVillages: Int!
  points: Int!
  rank: Int!
  exists: Boolean!
  rankAtt: Int!
  scoreAtt: Int!
  rankDef: Int!
  scoreDef: Int!
  rankSup: Int!
  scoreSup: Int!
  rankTotal: Int!
  scoreTotal: Int!
  dailyGrowth: Int!
  bestRank: Int!
  bestRankAt: Time!
  mostPoints: Int!
  mostPointsAt: Time!
  mostVillages: Int!
  mostVillagesAt: Time!
  joinedAt: Time!
  deletedAt: Time
  tribe: Tribe @goField(forceResolver: true)
  servers: [String!]! @goField(forceResolver: true)
  nameChanges: [PlayerNameChange!]! @goField(forceResolver: true)
}

type PlayerList {
  items: [Player!]
  total: Int!
}

input PlayerFilter {
  id: [Int!]
  idNEQ: [Int!]

  exists: Boolean

  name: [String!]
  nameNEQ: [String!]
  nameMATCH: String
  nameIEQ: String

  totalVillages: Int
  totalVillagesGT: Int
  totalVillagesGTE: Int
  totalVillagesLT: Int
  totalVillagesLTE: Int

  points: Int
  pointsGT: Int
  pointsGTE: Int
  pointsLT: Int
  pointsLTE: Int

  rank: Int
  rankGT: Int
  rankGTE: Int
  rankLT: Int
  rankLTE: Int

  rankAtt: Int
  rankAttGT: Int
  rankAttGTE: Int
  rankAttLT: Int
  rankAttLTE: Int

  scoreAtt: Int
  scoreAttGT: Int
  scoreAttGTE: Int
  scoreAttLT: Int
  scoreAttLTE: Int

  rankDef: Int
  rankDefGT: Int
  rankDefGTE: Int
  rankDefLT: Int
  rankDefLTE: Int

  scoreDef: Int
  scoreDefGT: Int
  scoreDefGTE: Int
  scoreDefLT: Int
  scoreDefLTE: Int

  rankSup: Int
  rankSupGT: Int
  rankSupGTE: Int
  rankSupLT: Int
  rankSupLTE: Int

  scoreSup: Int
  scoreSupGT: Int
  scoreSupGTE: Int
  scoreSupLT: Int
  scoreSupLTE: Int

  rankTotal: Int
  rankTotalGT: Int
  rankTotalGTE: Int
  rankTotalLT: Int
  rankTotalLTE: Int

  scoreTotal: Int
  scoreTotalGT: Int
  scoreTotalGTE: Int
  scoreTotalLT: Int
  scoreTotalLTE: Int

  dailyGrowth: Int
  dailyGrowthGT: Int
  dailyGrowthGTE: Int
  dailyGrowthLT: Int
  dailyGrowthLTE: Int

  joinedAt: Time
  joinedAtGT: Time
  joinedAtGTE: Time
  joinedAtLT: Time
  joinedAtLTE: Time

  deletedAt: Time
  deletedAtGT: Time
  deletedAtGTE: Time
  deletedAtLT: Time
  deletedAtLTE: Time

  tribeID: [Int!]
  tribeFilter: TribeFilter

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  players(server: String!, filter: PlayerFilter): PlayerList!
  player(server: String!, id: Int!): Player
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/player_history.graphql", Input: `type PlayerHistoryRecord {
  player: Player @goField(forceResolver: true)
  totalVillages: Int!
  points: Int!
  rank: Int!
  rankAtt: Int!
  scoreAtt: Int!
  rankDef: Int!
  scoreDef: Int!
  rankSup: Int!
  scoreSup: Int!
  rankTotal: Int!
  scoreTotal: Int!
  tribe: Tribe @goField(forceResolver: true)
  createDate: Time!
}

type PlayerHistory {
  total: Int!
  items: [PlayerHistoryRecord!]
}

input PlayerHistoryFilter {
  playerID: [Int!]
  playerIDNEQ: [Int!]

  createDate: Time
  createDateGT: Time
  createDateGTE: Time
  createDateLT: Time
  createDateLTE: Time

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  playerHistory(server: String!, filter: PlayerHistoryFilter): PlayerHistory!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/scalars.graphql", Input: `scalar Time
`, BuiltIn: false},
	&ast.Source{Name: "schema/server.graphql", Input: `enum ServerStatus {
  OPEN
  CLOSED
}

type Server {
  key: String!
  status: ServerStatus!
  numberOfPlayers: Int!
  numberOfTribes: Int!
  numberOfVillages: Int!

  langVersion: LangVersion @goField(forceResolver: true)

  config: ServerConfig!
  unitConfig: UnitConfig!
  buildingConfig: BuildingConfig!

  dataUpdatedAt: Time!
  historyUpdatedAt: Time!
  statsUpdatedAt: Time!
}

type ServerList {
  items: [Server!]
  total: Int!
}

input ServerFilter {
  key: [String!]
  keyNEQ: [String!]
  keyMATCH: String
  keyIEQ: String

  status: [ServerStatus!]
  statusNEQ: [ServerStatus!]

  langVersionTag: [LanguageTag!]
  langVersionTagNEQ: [LanguageTag!]

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  servers(filter: ServerFilter): ServerList!
  server(key: String!): Server
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/server_config.graphql", Input: `type ServerConfigBuild {
  destroy: Int!
}

type ServerConfigMisc {
  killRanking: Int!
  tutorial: Int!
  tradeCancelTime: Int!
}

type ServerConfigCommands {
  millisArrival: Int!
  commandCancelTime: Int!
}

type ServerConfigNewbie {
  days: Int!
  ratioDays: Int!
  ratio: Int!
  removeNewbieVillages: Int!
}

type ServerConfigGame {
  buildtimeFormula: Int!
  knight: Int!
  knightNewItems: Boolean!
  archer: Int!
  tech: Int!
  farmLimit: Int!
  church: Int!
  watchtower: Int!
  stronghold: Int!
  fakeLimit: Int!
  barbarianRise: Float!
  barbarianShrink: Int!
  barbarianMaxPoints: Int!
  hauls: Int!
  haulsBase: Int!
  haulsMax: Int!
  baseProduction: Int!
  event: Int!
  suppressEvents: Int!
}

type ServerConfigBuildings {
  customMain: Int!
  customFarm: Int!
  customStorage: Int!
  customPlace: Int!
  customBarracks: Int!
  customChurch: Int!
  customSmith: Int!
  customWood: Int!
  customStone: Int!
  customIron: Int!
  customMarket: Int!
  customStable: Int!
  customWall: Int!
  customGarage: Int!
  customHide: Int!
  customSnob: Int!
  customStatue: Int!
  customWatchtower: Int!
}

type ServerConfigSnob {
  gold: Int!
  cheapRebuild: Int!
  rise: Int!
  maxDist: Int!
  factor: Float!
  coinWood: Int!
  coinStone: Int!
  coinIron: Int!
  noBarbConquer: Boolean!
}

type ServerConfigAlly {
  noHarm: Int!
  noOtherSupport: Int!
  allytimeSupport: Int!
  noLeave: Int!
  noJoin: Int!
  limit: Int!
  fixedAllies: Int!
  pointsMemberCount: Int!
  warsMemberRequirement: Int!
  warsPointsRequirement: Int!
  warsAutoacceptDays: Int!
  levels: Int!
  xpRequirements: String!
}

type ServerConfigCoord {
  mapSize: Int!
  func: Int!
  emptyVillages: Int!
  bonusVillages: Int!
  bonusNew: Int!
  inner: Int!
  selectStart: Int!
  villageMoveWait: Int!
  nobleRestart: Int!
  startVillages: Int!
}

type ServerConfigSitter {
  allow: Int!
}

type ServerConfigSleep {
  active: Int!
  delay: Int!
  min: Int!
  max: Int!
  minAwake: Int!
  maxAwake: Int!
  warnTime: Int!
}

type ServerConfigNight {
  active: Int!
  startHour: Int!
  endHour: Int!
  defFactor: Float!
}

type ServerConfigWin {
  check: Int!
}

type ServerConfig {
  speed: Float!
  unitSpeed: Float!
  moral: Int!
  build: ServerConfigBuild!
  misc: ServerConfigMisc!
  commands: ServerConfigCommands!
  newbie: ServerConfigNewbie!
  game: ServerConfigGame!
  buildings: ServerConfigBuildings!
  snob: ServerConfigSnob!
  ally: ServerConfigAlly!
  coord: ServerConfigCoord!
  sitter: ServerConfigSitter!
  sleep: ServerConfigSleep!
  night: ServerConfigNight!
  win: ServerConfigWin!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/server_stats.graphql", Input: `type ServerStatsRecord {
  activePlayers: Int!
  inactivePlayers: Int!
  players: Int!
  activeTribes: Int!
  inactiveTribes: Int!
  tribes: Int!
  bonusVillages: Int!
  barbarianVillages: Int!
  playerVillages: Int!
  villages: Int!
  createDate: Time!
}

type ServerStats {
  items: [ServerStatsRecord!]
  total: Int!
}

input ServerStatsFilter {
  createDate: Time
  createDateGT: Time
  createDateGTE: Time
  createDateLT: Time
  createDateLTE: Time

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  serverStats(server: String!, filter: ServerStatsFilter): ServerStats!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/tribe.graphql", Input: `type Tribe {
  id: Int!
  name: String!
  tag: String!
  totalMembers: Int!
  totalVillages: Int!
  points: Int!
  allPoints: Int!
  rank: Int!
  exists: Boolean!
  rankAtt: Int!
  scoreAtt: Int!
  rankDef: Int!
  scoreDef: Int!
  rankTotal: Int!
  scoreTotal: Int!
  dominance: Float!
  bestRank: Int!
  bestRankAt: Time!
  mostPoints: Int!
  mostPointsAt: Time!
  mostVillages: Int!
  mostVillagesAt: Time!
  createdAt: Time!
  deletedAt: Time
}

type TribeList {
  items: [Tribe!]
  total: Int!
}

input TribeFilter {
  id: [Int!]
  idNEQ: [Int!]

  exists: Boolean

  tag: [String!]
  tagNEQ: [String!]
  tagMATCH: String
  tagIEQ: String

  name: [String!]
  nameNEQ: [String!]
  nameMATCH: String
  nameIEQ: String

  totalMembers: Int
  totalMembersGT: Int
  totalMembersGTE: Int
  totalMembersLT: Int
  totalMembersLTE: Int

  totalVillages: Int
  totalVillagesGT: Int
  totalVillagesGTE: Int
  totalVillagesLT: Int
  totalVillagesLTE: Int

  points: Int
  pointsGT: Int
  pointsGTE: Int
  pointsLT: Int
  pointsLTE: Int

  allPoints: Int
  allPointsGT: Int
  allPointsGTE: Int
  allPointsLT: Int
  allPointsLTE: Int

  rank: Int
  rankGT: Int
  rankGTE: Int
  rankLT: Int
  rankLTE: Int

  rankAtt: Int
  rankAttGT: Int
  rankAttGTE: Int
  rankAttLT: Int
  rankAttLTE: Int

  scoreAtt: Int
  scoreAttGT: Int
  scoreAttGTE: Int
  scoreAttLT: Int
  scoreAttLTE: Int

  rankDef: Int
  rankDefGT: Int
  rankDefGTE: Int
  rankDefLT: Int
  rankDefLTE: Int

  scoreDef: Int
  scoreDefGT: Int
  scoreDefGTE: Int
  scoreDefLT: Int
  scoreDefLTE: Int

  rankTotal: Int
  rankTotalGT: Int
  rankTotalGTE: Int
  rankTotalLT: Int
  rankTotalLTE: Int

  scoreTotal: Int
  scoreTotalGT: Int
  scoreTotalGTE: Int
  scoreTotalLT: Int
  scoreTotalLTE: Int

  dominance: Int
  dominanceGT: Int
  dominanceGTE: Int
  dominanceLT: Int
  dominanceLTE: Int

  createdAt: Time
  createdAtGT: Time
  createdAtGTE: Time
  createdAtLT: Time
  createdAtLTE: Time

  deletedAt: Time
  deletedAtGT: Time
  deletedAtGTE: Time
  deletedAtLT: Time
  deletedAtLTE: Time

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  tribes(server: String!, filter: TribeFilter): TribeList!
  tribe(server: String!, id: Int!): Tribe
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/tribe_change.graphql", Input: `type TribeChangeRecord {
  player: Player @goField(forceResolver: true)
  oldTribe: Tribe @goField(forceResolver: true)
  newTribe: Tribe @goField(forceResolver: true)
  createdAt: Time!
}

type TribeChanges {
  total: Int!
  items: [TribeChangeRecord!]
}

input TribeChangeFilter {
  playerID: [Int!]
  playerIDNEQ: [Int!]

  oldTribeID: [Int!]
  oldTribeIDNEQ: [Int!]

  newTribeID: [Int!]
  newTribeIDNEQ: [Int!]

  createdAt: Time
  createdAtGT: Time
  createdAtGTE: Time
  createdAtLT: Time
  createdAtLTE: Time

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  tribeChanges(server: String!, filter: TribeChangeFilter): TribeChanges!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/tribe_history.graphql", Input: `type TribeHistoryRecord {
  tribe: Tribe @goField(forceResolver: true)
  totalVillages: Int!
  totalMembers: Int!
  points: Int!
  allPoints: Int!
  rank: Int!
  dominance: Float!
  rankAtt: Int!
  scoreAtt: Int!
  rankDef: Int!
  scoreDef: Int!
  rankTotal: Int!
  scoreTotal: Int!
  createDate: Time!
}

type TribeHistory {
  total: Int!
  items: [TribeHistoryRecord!]
}

input TribeHistoryFilter {
  tribeID: [Int!]
  tribeIDNEQ: [Int!]

  createDate: Time
  createDateGT: Time
  createDateGTE: Time
  createDateLT: Time
  createDateLTE: Time

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  tribeHistory(server: String!, filter: TribeHistoryFilter): TribeHistory!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/unit_config.graphql", Input: `type Unit {
  buildTime: Float!
  pop: Int!
  speed: Float!
  attack: Int!
  defense: Int!
  defenseCavalry: Int!
  defenseArcher: Int!
  carry: Int!
}

type UnitConfig {
  spear: Unit!
  sword: Unit!
  axe: Unit!
  archer: Unit!
  spy: Unit!
  light: Unit!
  marcher: Unit!
  heavy: Unit!
  ram: Unit!
  catapult: Unit!
  knight: Unit!
  snob: Unit!
  militia: Unit!
}
`, BuiltIn: false},
	&ast.Source{Name: "schema/village.graphql", Input: `type Village {
  id: Int!
  name: String!
  points: Int!
  x: Int!
  y: Int!
  bonus: Int!
  player: Player @goField(forceResolver: true)
}

type VillageList {
  items: [Village!]
  total: Int!
}

input VillageFilter {
  id: [Int!]
  idNEQ: [Int!]

  name: [String!]
  nameNEQ: [String!]
  nameMATCH: String
  nameIEQ: String

  points: Int
  pointsGT: Int
  pointsGTE: Int
  pointsLT: Int
  pointsLTE: Int

  xGT: Int
  xGTE: Int
  xLT: Int
  xLTE: Int
  yGT: Int
  yGTE: Int
  yLT: Int
  yLTE: Int

  bonus: Int
  bonusGT: Int
  bonusGTE: Int
  bonusLT: Int
  bonusLTE: Int

  playerID: [Int!]
  playerFilter: PlayerFilter

  offset: Int
  limit: Int
  sort: String
}

extend type Query {
  villages(server: String!, filter: VillageFilter): VillageList!
  village(server: String!, id: Int!): Village
}
`, BuiltIn: false},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)

// endregion ************************** generated!.gotpl **************************

// region    ***************************** args.gotpl *****************************

func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["name"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["name"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_dailyPlayerStats_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.DailyPlayerStatsFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalODailyPlayerStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyPlayerStatsFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_dailyTribeStats_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.DailyTribeStatsFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalODailyTribeStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyTribeStatsFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_ennoblements_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.EnnoblementFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalOEnnoblementFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblementFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_langVersion_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 models.LanguageTag
	if tmp, ok := rawArgs["tag"]; ok {
		arg0, err = ec.unmarshalNLanguageTag2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTag(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["tag"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_langVersions_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *models.LangVersionFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg0, err = ec.unmarshalOLangVersionFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersionFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_liveEnnoblements_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_playerHistory_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.PlayerHistoryFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalOPlayerHistoryFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerHistoryFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_player_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 int
	if tmp, ok := rawArgs["id"]; ok {
		arg1, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_players_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.PlayerFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_serverStats_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.ServerStatsFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalOServerStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatsFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_server_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["key"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["key"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_servers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *models.ServerFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg0, err = ec.unmarshalOServerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_tribeChanges_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.TribeChangeFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalOTribeChangeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_tribeHistory_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.TribeHistoryFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalOTribeHistoryFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeHistoryFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_tribe_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 int
	if tmp, ok := rawArgs["id"]; ok {
		arg1, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_tribes_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.TribeFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_village_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 int
	if tmp, ok := rawArgs["id"]; ok {
		arg1, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_villages_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["server"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *models.VillageFilter
	if tmp, ok := rawArgs["filter"]; ok {
		arg1, err = ec.unmarshalOVillageFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillageFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	return args, nil
}

func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 bool
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 bool
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

// endregion ***************************** args.gotpl *****************************

// region    ************************** directives.gotpl **************************

// endregion ************************** directives.gotpl **************************

// region    **************************** field.gotpl *****************************

func (ec *executionContext) _Building_maxLevel(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MaxLevel, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_minLevel(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MinLevel, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_wood(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Wood, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_stone(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Stone, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_iron(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Iron, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_pop(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Pop, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_woodFactor(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.WoodFactor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_stoneFactor(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StoneFactor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_ironFactor(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IronFactor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_popFactor(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PopFactor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_buildTime(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BuildTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Building_buildTimeFactor(ctx context.Context, field graphql.CollectedField, obj *models.Building) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Building",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BuildTimeFactor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_main(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Main, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_barracks(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Barracks, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_stable(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Stable, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_garage(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Garage, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_watchtower(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Watchtower, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_snob(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Snob, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_smith(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Smith, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_place(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Place, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_statue(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Statue, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_market(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Market, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_wood(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Wood, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_stone(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Stone, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_iron(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Iron, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_farm(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Farm, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_storage(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Storage, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_hide(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Hide, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_wall(ctx context.Context, field graphql.CollectedField, obj *models.BuildingConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "BuildingConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Wall, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStats_total(ctx context.Context, field graphql.CollectedField, obj *DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStats",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStats_items(ctx context.Context, field graphql.CollectedField, obj *DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStats",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.DailyPlayerStats)
	fc.Result = res
	return ec.marshalODailyPlayerStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyPlayerStatsᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_player(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.DailyPlayerStatsRecord().Player(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_villages(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Villages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_points(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Points, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_rank(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Rank, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_rankAtt(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_scoreAtt(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_rankDef(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_scoreDef(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_rankSup(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankSup, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_scoreSup(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreSup, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_rankTotal(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_scoreTotal(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_createDate(ctx context.Context, field graphql.CollectedField, obj *models.DailyPlayerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyPlayerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreateDate, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStats_total(ctx context.Context, field graphql.CollectedField, obj *DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStats",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStats_items(ctx context.Context, field graphql.CollectedField, obj *DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStats",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.DailyTribeStats)
	fc.Result = res
	return ec.marshalODailyTribeStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyTribeStatsᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_tribe(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.DailyTribeStatsRecord().Tribe(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_members(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Members, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_villages(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Villages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_points(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Points, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_allPoints(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.AllPoints, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_rank(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Rank, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_rankAtt(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_scoreAtt(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_rankDef(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_scoreDef(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_rankTotal(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_scoreTotal(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_dominance(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Dominance, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_createDate(ctx context.Context, field graphql.CollectedField, obj *models.DailyTribeStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "DailyTribeStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreateDate, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_village(ctx context.Context, field graphql.CollectedField, obj *models.Ennoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Ennoblement",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Ennoblement().Village(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Village)
	fc.Result = res
	return ec.marshalOVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillage(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_newOwner(ctx context.Context, field graphql.CollectedField, obj *models.Ennoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Ennoblement",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Ennoblement().NewOwner(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_newOwnerTribe(ctx context.Context, field graphql.CollectedField, obj *models.Ennoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Ennoblement",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Ennoblement().NewOwnerTribe(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_oldOwner(ctx context.Context, field graphql.CollectedField, obj *models.Ennoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Ennoblement",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Ennoblement().OldOwner(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_oldOwnerTribe(ctx context.Context, field graphql.CollectedField, obj *models.Ennoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Ennoblement",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Ennoblement().OldOwnerTribe(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_ennobledAt(ctx context.Context, field graphql.CollectedField, obj *models.Ennoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Ennoblement",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EnnobledAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _EnnoblementList_items(ctx context.Context, field graphql.CollectedField, obj *EnnoblementList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "EnnoblementList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.Ennoblement)
	fc.Result = res
	return ec.marshalOEnnoblement2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblementᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _EnnoblementList_total(ctx context.Context, field graphql.CollectedField, obj *EnnoblementList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "EnnoblementList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _LangVersion_tag(ctx context.Context, field graphql.CollectedField, obj *models.LangVersion) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LangVersion",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Tag, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.LanguageTag)
	fc.Result = res
	return ec.marshalNLanguageTag2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTag(ctx, field.Selections, res)
}

func (ec *executionContext) _LangVersion_name(ctx context.Context, field graphql.CollectedField, obj *models.LangVersion) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LangVersion",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _LangVersion_host(ctx context.Context, field graphql.CollectedField, obj *models.LangVersion) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LangVersion",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Host, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _LangVersion_timezone(ctx context.Context, field graphql.CollectedField, obj *models.LangVersion) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LangVersion",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Timezone, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _LangVersionList_items(ctx context.Context, field graphql.CollectedField, obj *LangVersionList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LangVersionList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.LangVersion)
	fc.Result = res
	return ec.marshalOLangVersion2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersionᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _LangVersionList_total(ctx context.Context, field graphql.CollectedField, obj *LangVersionList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LangVersionList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _LiveEnnoblement_village(ctx context.Context, field graphql.CollectedField, obj *models.LiveEnnoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LiveEnnoblement",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.LiveEnnoblement().Village(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Village)
	fc.Result = res
	return ec.marshalOVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillage(ctx, field.Selections, res)
}

func (ec *executionContext) _LiveEnnoblement_newOwner(ctx context.Context, field graphql.CollectedField, obj *models.LiveEnnoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LiveEnnoblement",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.LiveEnnoblement().NewOwner(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _LiveEnnoblement_oldOwner(ctx context.Context, field graphql.CollectedField, obj *models.LiveEnnoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LiveEnnoblement",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.LiveEnnoblement().OldOwner(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _LiveEnnoblement_ennobledAt(ctx context.Context, field graphql.CollectedField, obj *models.LiveEnnoblement) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "LiveEnnoblement",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EnnobledAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_id(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_name(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_totalVillages(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TotalVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_points(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Points, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_rank(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Rank, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_exists(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Exists, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bool)
	fc.Result = res
	return ec.marshalNBoolean2ᚖbool(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_rankAtt(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_scoreAtt(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_rankDef(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_scoreDef(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_rankSup(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankSup, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_scoreSup(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreSup, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_rankTotal(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_scoreTotal(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_dailyGrowth(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DailyGrowth, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_bestRank(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BestRank, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_bestRankAt(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BestRankAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_mostPoints(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MostPoints, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_mostPointsAt(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MostPointsAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_mostVillages(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MostVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_mostVillagesAt(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MostVillagesAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_joinedAt(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.JoinedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_deletedAt(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeletedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_tribe(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Player().Tribe(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_servers(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Player().Servers(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalNString2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_nameChanges(ctx context.Context, field graphql.CollectedField, obj *models.Player) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Player",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Player().NameChanges(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*models.PlayerNameChange)
	fc.Result = res
	return ec.marshalNPlayerNameChange2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerNameChangeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistory_total(ctx context.Context, field graphql.CollectedField, obj *PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistory",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistory_items(ctx context.Context, field graphql.CollectedField, obj *PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistory",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.PlayerHistory)
	fc.Result = res
	return ec.marshalOPlayerHistoryRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerHistoryᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_player(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.PlayerHistoryRecord().Player(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_totalVillages(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TotalVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_points(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Points, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_rank(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Rank, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_rankAtt(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_scoreAtt(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_rankDef(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_scoreDef(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_rankSup(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankSup, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_scoreSup(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreSup, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_rankTotal(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_scoreTotal(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_tribe(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.PlayerHistoryRecord().Tribe(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_createDate(ctx context.Context, field graphql.CollectedField, obj *models.PlayerHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreateDate, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerList_items(ctx context.Context, field graphql.CollectedField, obj *PlayerList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerList_total(ctx context.Context, field graphql.CollectedField, obj *PlayerList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerNameChange_oldName(ctx context.Context, field graphql.CollectedField, obj *models.PlayerNameChange) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerNameChange",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.OldName, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerNameChange_newName(ctx context.Context, field graphql.CollectedField, obj *models.PlayerNameChange) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerNameChange",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NewName, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerNameChange_changeDate(ctx context.Context, field graphql.CollectedField, obj *models.PlayerNameChange) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "PlayerNameChange",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ChangeDate, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_dailyPlayerStats(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_dailyPlayerStats_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().DailyPlayerStats(rctx, args["server"].(string), args["filter"].(*models.DailyPlayerStatsFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*DailyPlayerStats)
	fc.Result = res
	return ec.marshalNDailyPlayerStats2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐDailyPlayerStats(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_dailyTribeStats(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_dailyTribeStats_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().DailyTribeStats(rctx, args["server"].(string), args["filter"].(*models.DailyTribeStatsFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*DailyTribeStats)
	fc.Result = res
	return ec.marshalNDailyTribeStats2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐDailyTribeStats(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_ennoblements(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_ennoblements_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Ennoblements(rctx, args["server"].(string), args["filter"].(*models.EnnoblementFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*EnnoblementList)
	fc.Result = res
	return ec.marshalNEnnoblementList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐEnnoblementList(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_langVersions(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_langVersions_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().LangVersions(rctx, args["filter"].(*models.LangVersionFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*LangVersionList)
	fc.Result = res
	return ec.marshalNLangVersionList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐLangVersionList(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_langVersion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_langVersion_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().LangVersion(rctx, args["tag"].(models.LanguageTag))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.LangVersion)
	fc.Result = res
	return ec.marshalOLangVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersion(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_liveEnnoblements(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_liveEnnoblements_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().LiveEnnoblements(rctx, args["server"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.LiveEnnoblement)
	fc.Result = res
	return ec.marshalOLiveEnnoblement2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLiveEnnoblementᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_players(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_players_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Players(rctx, args["server"].(string), args["filter"].(*models.PlayerFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*PlayerList)
	fc.Result = res
	return ec.marshalNPlayerList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐPlayerList(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_player(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_player_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Player(rctx, args["server"].(string), args["id"].(int))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_playerHistory(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_playerHistory_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().PlayerHistory(rctx, args["server"].(string), args["filter"].(*models.PlayerHistoryFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*PlayerHistory)
	fc.Result = res
	return ec.marshalNPlayerHistory2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐPlayerHistory(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_servers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_servers_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Servers(rctx, args["filter"].(*models.ServerFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*ServerList)
	fc.Result = res
	return ec.marshalNServerList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐServerList(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_server(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_server_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Server(rctx, args["key"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Server)
	fc.Result = res
	return ec.marshalOServer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServer(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_serverStats(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_serverStats_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().ServerStats(rctx, args["server"].(string), args["filter"].(*models.ServerStatsFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*ServerStats)
	fc.Result = res
	return ec.marshalNServerStats2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐServerStats(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_tribes(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_tribes_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Tribes(rctx, args["server"].(string), args["filter"].(*models.TribeFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TribeList)
	fc.Result = res
	return ec.marshalNTribeList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeList(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_tribe(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_tribe_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Tribe(rctx, args["server"].(string), args["id"].(int))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_tribeChanges(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_tribeChanges_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().TribeChanges(rctx, args["server"].(string), args["filter"].(*models.TribeChangeFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TribeChanges)
	fc.Result = res
	return ec.marshalNTribeChanges2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeChanges(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_tribeHistory(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_tribeHistory_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().TribeHistory(rctx, args["server"].(string), args["filter"].(*models.TribeHistoryFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TribeHistory)
	fc.Result = res
	return ec.marshalNTribeHistory2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeHistory(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_villages(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_villages_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Villages(rctx, args["server"].(string), args["filter"].(*models.VillageFilter))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*VillageList)
	fc.Result = res
	return ec.marshalNVillageList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐVillageList(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_village(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_village_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Village(rctx, args["server"].(string), args["id"].(int))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Village)
	fc.Result = res
	return ec.marshalOVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillage(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query___type_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectType(args["name"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectSchema()
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Schema)
	fc.Result = res
	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_key(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Key, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_status(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Status, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerStatus)
	fc.Result = res
	return ec.marshalNServerStatus2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatus(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_numberOfPlayers(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NumberOfPlayers, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_numberOfTribes(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NumberOfTribes, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_numberOfVillages(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NumberOfVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_langVersion(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Server().LangVersion(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.LangVersion)
	fc.Result = res
	return ec.marshalOLangVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersion(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_config(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Config, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfig)
	fc.Result = res
	return ec.marshalNServerConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfig(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_unitConfig(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UnitConfig, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.UnitConfig)
	fc.Result = res
	return ec.marshalNUnitConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnitConfig(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_buildingConfig(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BuildingConfig, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BuildingConfig)
	fc.Result = res
	return ec.marshalNBuildingConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuildingConfig(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_dataUpdatedAt(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DataUpdatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_historyUpdatedAt(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.HistoryUpdatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_statsUpdatedAt(ctx context.Context, field graphql.CollectedField, obj *models.Server) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Server",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StatsUpdatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_speed(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Speed, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_unitSpeed(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UnitSpeed, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_moral(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Moral, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_build(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Build, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigBuild)
	fc.Result = res
	return ec.marshalNServerConfigBuild2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigBuild(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_misc(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Misc, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigMisc)
	fc.Result = res
	return ec.marshalNServerConfigMisc2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigMisc(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_commands(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Commands, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigCommands)
	fc.Result = res
	return ec.marshalNServerConfigCommands2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigCommands(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_newbie(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Newbie, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigNewbie)
	fc.Result = res
	return ec.marshalNServerConfigNewbie2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigNewbie(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_game(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Game, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigGame)
	fc.Result = res
	return ec.marshalNServerConfigGame2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigGame(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_buildings(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Buildings, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigBuildings)
	fc.Result = res
	return ec.marshalNServerConfigBuildings2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigBuildings(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_snob(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Snob, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigSnob)
	fc.Result = res
	return ec.marshalNServerConfigSnob2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigSnob(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_ally(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Ally, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigAlly)
	fc.Result = res
	return ec.marshalNServerConfigAlly2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigAlly(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_coord(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Coord, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigCoord)
	fc.Result = res
	return ec.marshalNServerConfigCoord2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigCoord(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_sitter(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Sitter, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigSitter)
	fc.Result = res
	return ec.marshalNServerConfigSitter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigSitter(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_sleep(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Sleep, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigSleep)
	fc.Result = res
	return ec.marshalNServerConfigSleep2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigSleep(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_night(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Night, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigNight)
	fc.Result = res
	return ec.marshalNServerConfigNight2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigNight(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_win(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Win, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.ServerConfigWin)
	fc.Result = res
	return ec.marshalNServerConfigWin2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigWin(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_noHarm(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NoHarm, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_noOtherSupport(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NoOtherSupport, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_allytimeSupport(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.AllytimeSupport, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_noLeave(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NoLeave, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_noJoin(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NoJoin, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_limit(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Limit, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_fixedAllies(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.FixedAllies, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_pointsMemberCount(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PointsMemberCount, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_warsMemberRequirement(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.WarsMemberRequirement, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_warsPointsRequirement(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.WarsPointsRequirement, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_warsAutoacceptDays(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.WarsAutoacceptDays, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_levels(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Levels, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_xpRequirements(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigAlly) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigAlly",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XpRequirements, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuild_destroy(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuild) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuild",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Destroy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customMain(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomMain, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customFarm(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomFarm, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customStorage(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomStorage, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customPlace(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomPlace, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customBarracks(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomBarracks, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customChurch(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomChurch, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customSmith(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomSmith, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customWood(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomWood, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customStone(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomStone, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customIron(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomIron, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customMarket(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomMarket, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customStable(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomStable, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customWall(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomWall, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customGarage(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomGarage, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customHide(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomHide, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customSnob(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomSnob, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customStatue(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomStatue, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigBuildings_customWatchtower(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigBuildings) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigBuildings",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CustomWatchtower, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCommands_millisArrival(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCommands) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCommands",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MillisArrival, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCommands_commandCancelTime(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCommands) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCommands",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CommandCancelTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_mapSize(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MapSize, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_func(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Func, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_emptyVillages(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EmptyVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_bonusVillages(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BonusVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_bonusNew(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BonusNew, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_inner(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Inner, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_selectStart(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SelectStart, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_villageMoveWait(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.VillageMoveWait, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_nobleRestart(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NobleRestart, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigCoord_startVillages(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigCoord) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigCoord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StartVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_buildtimeFormula(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BuildtimeFormula, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_knight(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Knight, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_knightNewItems(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.KnightNewItems, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_archer(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Archer, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_tech(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Tech, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_farmLimit(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.FarmLimit, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_church(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Church, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_watchtower(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Watchtower, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_stronghold(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Stronghold, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_fakeLimit(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.FakeLimit, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_barbarianRise(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BarbarianRise, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_barbarianShrink(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BarbarianShrink, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_barbarianMaxPoints(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BarbarianMaxPoints, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_hauls(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Hauls, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_haulsBase(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.HaulsBase, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_haulsMax(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.HaulsMax, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_baseProduction(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BaseProduction, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_event(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Event, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_suppressEvents(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigGame) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigGame",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SuppressEvents, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigMisc_killRanking(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigMisc) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigMisc",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.KillRanking, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigMisc_tutorial(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigMisc) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigMisc",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Tutorial, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigMisc_tradeCancelTime(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigMisc) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigMisc",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TradeCancelTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigNewbie_days(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigNewbie) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigNewbie",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Days, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigNewbie_ratioDays(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigNewbie) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigNewbie",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RatioDays, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigNewbie_ratio(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigNewbie) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigNewbie",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Ratio, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigNewbie_removeNewbieVillages(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigNewbie) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigNewbie",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RemoveNewbieVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigNight_active(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigNight) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigNight",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Active, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigNight_startHour(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigNight) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigNight",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StartHour, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigNight_endHour(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigNight) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigNight",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EndHour, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigNight_defFactor(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigNight) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigNight",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DefFactor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSitter_allow(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSitter) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSitter",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Allow, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSleep_active(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSleep) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSleep",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Active, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSleep_delay(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSleep) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSleep",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Delay, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSleep_min(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSleep) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSleep",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Min, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSleep_max(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSleep) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSleep",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Max, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSleep_minAwake(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSleep) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSleep",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MinAwake, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSleep_maxAwake(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSleep) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSleep",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MaxAwake, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSleep_warnTime(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSleep) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSleep",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.WarnTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSnob_gold(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSnob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSnob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Gold, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSnob_cheapRebuild(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSnob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSnob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CheapRebuild, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSnob_rise(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSnob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSnob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Rise, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSnob_maxDist(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSnob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSnob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MaxDist, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSnob_factor(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSnob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSnob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Factor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSnob_coinWood(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSnob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSnob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CoinWood, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSnob_coinStone(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSnob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSnob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CoinStone, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSnob_coinIron(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSnob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSnob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CoinIron, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigSnob_noBarbConquer(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigSnob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigSnob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NoBarbConquer, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigWin_check(ctx context.Context, field graphql.CollectedField, obj *models.ServerConfigWin) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerConfigWin",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Check, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerList_items(ctx context.Context, field graphql.CollectedField, obj *ServerList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.Server)
	fc.Result = res
	return ec.marshalOServer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerList_total(ctx context.Context, field graphql.CollectedField, obj *ServerList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStats_items(ctx context.Context, field graphql.CollectedField, obj *ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStats",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.ServerStats)
	fc.Result = res
	return ec.marshalOServerStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatsᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStats_total(ctx context.Context, field graphql.CollectedField, obj *ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStats",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_activePlayers(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ActivePlayers, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_inactivePlayers(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.InactivePlayers, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_players(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Players, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_activeTribes(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ActiveTribes, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_inactiveTribes(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.InactiveTribes, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_tribes(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Tribes, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_bonusVillages(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BonusVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_barbarianVillages(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BarbarianVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_playerVillages(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PlayerVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_villages(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Villages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_createDate(ctx context.Context, field graphql.CollectedField, obj *models.ServerStats) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ServerStatsRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreateDate, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_id(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_name(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_tag(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Tag, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_totalMembers(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TotalMembers, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_totalVillages(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TotalVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_points(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Points, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_allPoints(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.AllPoints, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_rank(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Rank, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_exists(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Exists, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bool)
	fc.Result = res
	return ec.marshalNBoolean2ᚖbool(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_rankAtt(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_scoreAtt(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_rankDef(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_scoreDef(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_rankTotal(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_scoreTotal(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_dominance(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Dominance, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_bestRank(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BestRank, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_bestRankAt(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BestRankAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_mostPoints(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MostPoints, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_mostPointsAt(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MostPointsAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_mostVillages(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MostVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_mostVillagesAt(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MostVillagesAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_createdAt(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Tribe_deletedAt(ctx context.Context, field graphql.CollectedField, obj *models.Tribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Tribe",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeletedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeChangeRecord_player(ctx context.Context, field graphql.CollectedField, obj *models.TribeChange) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeChangeRecord",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TribeChangeRecord().Player(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeChangeRecord_oldTribe(ctx context.Context, field graphql.CollectedField, obj *models.TribeChange) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeChangeRecord",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TribeChangeRecord().OldTribe(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeChangeRecord_newTribe(ctx context.Context, field graphql.CollectedField, obj *models.TribeChange) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeChangeRecord",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TribeChangeRecord().NewTribe(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeChangeRecord_createdAt(ctx context.Context, field graphql.CollectedField, obj *models.TribeChange) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeChangeRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeChanges_total(ctx context.Context, field graphql.CollectedField, obj *TribeChanges) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeChanges",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeChanges_items(ctx context.Context, field graphql.CollectedField, obj *TribeChanges) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeChanges",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.TribeChange)
	fc.Result = res
	return ec.marshalOTribeChangeRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistory_total(ctx context.Context, field graphql.CollectedField, obj *TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistory",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistory_items(ctx context.Context, field graphql.CollectedField, obj *TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistory",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.TribeHistory)
	fc.Result = res
	return ec.marshalOTribeHistoryRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeHistoryᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_tribe(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TribeHistoryRecord().Tribe(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_totalVillages(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TotalVillages, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_totalMembers(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TotalMembers, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_points(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Points, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_allPoints(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.AllPoints, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_rank(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Rank, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_dominance(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Dominance, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_rankAtt(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_scoreAtt(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreAtt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_rankDef(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_scoreDef(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreDef, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_rankTotal(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RankTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_scoreTotal(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ScoreTotal, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_createDate(ctx context.Context, field graphql.CollectedField, obj *models.TribeHistory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeHistoryRecord",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreateDate, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeList_items(ctx context.Context, field graphql.CollectedField, obj *TribeList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeList_total(ctx context.Context, field graphql.CollectedField, obj *TribeList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "TribeList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Unit_buildTime(ctx context.Context, field graphql.CollectedField, obj *models.Unit) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Unit",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BuildTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Unit_pop(ctx context.Context, field graphql.CollectedField, obj *models.Unit) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Unit",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Pop, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Unit_speed(ctx context.Context, field graphql.CollectedField, obj *models.Unit) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Unit",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Speed, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Unit_attack(ctx context.Context, field graphql.CollectedField, obj *models.Unit) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Unit",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Attack, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Unit_defense(ctx context.Context, field graphql.CollectedField, obj *models.Unit) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Unit",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Defense, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Unit_defenseCavalry(ctx context.Context, field graphql.CollectedField, obj *models.Unit) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Unit",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DefenseCavalry, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Unit_defenseArcher(ctx context.Context, field graphql.CollectedField, obj *models.Unit) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Unit",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DefenseArcher, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Unit_carry(ctx context.Context, field graphql.CollectedField, obj *models.Unit) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Unit",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Carry, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_spear(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Spear, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_sword(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Sword, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_axe(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Axe, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_archer(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Archer, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_spy(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Spy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_light(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Light, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_marcher(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Marcher, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_heavy(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Heavy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_ram(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Ram, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_catapult(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Catapult, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_knight(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Knight, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_snob(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Snob, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_militia(ctx context.Context, field graphql.CollectedField, obj *models.UnitConfig) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UnitConfig",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Militia, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _Village_id(ctx context.Context, field graphql.CollectedField, obj *models.Village) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Village",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Village_name(ctx context.Context, field graphql.CollectedField, obj *models.Village) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Village",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Village_points(ctx context.Context, field graphql.CollectedField, obj *models.Village) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Village",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Points, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Village_x(ctx context.Context, field graphql.CollectedField, obj *models.Village) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Village",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.X, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Village_y(ctx context.Context, field graphql.CollectedField, obj *models.Village) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Village",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Y, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Village_bonus(ctx context.Context, field graphql.CollectedField, obj *models.Village) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Village",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bonus, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Village_player(ctx context.Context, field graphql.CollectedField, obj *models.Village) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Village",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Village().Player(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*models.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _VillageList_items(ctx context.Context, field graphql.CollectedField, obj *VillageList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "VillageList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Items, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*models.Village)
	fc.Result = res
	return ec.marshalOVillage2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillageᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _VillageList_total(ctx context.Context, field graphql.CollectedField, obj *VillageList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "VillageList",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Directive",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Directive",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Directive",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Locations, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Directive",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Args, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.InputValue)
	fc.Result = res
	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__EnumValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__EnumValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__EnumValue",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsDeprecated(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__EnumValue",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeprecationReason(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Args, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.InputValue)
	fc.Result = res
	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Type, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsDeprecated(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeprecationReason(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__InputValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__InputValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__InputValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Type, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__InputValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DefaultValue, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Types(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.QueryType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MutationType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SubscriptionType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Directives(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.Directive)
	fc.Result = res
	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Kind(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field___Type_fields_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Fields(args["includeDeprecated"].(bool)), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.Field)
	fc.Result = res
	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Interfaces(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PossibleTypes(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.EnumValue)
	fc.Result = res
	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.InputFields(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.InputValue)
	fc.Result = res
	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.OfType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

// endregion **************************** field.gotpl *****************************

// region    **************************** input.gotpl *****************************

func (ec *executionContext) unmarshalInputDailyPlayerStatsFilter(ctx context.Context, obj interface{}) (models.DailyPlayerStatsFilter, error) {
	var it models.DailyPlayerStatsFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "playerID":
			var err error
			it.PlayerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerIDNEQ":
			var err error
			it.PlayerIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDate":
			var err error
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputDailyTribeStatsFilter(ctx context.Context, obj interface{}) (models.DailyTribeStatsFilter, error) {
	var it models.DailyTribeStatsFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "tribeID":
			var err error
			it.TribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeIDNEQ":
			var err error
			it.TribeIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDate":
			var err error
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputEnnoblementFilter(ctx context.Context, obj interface{}) (models.EnnoblementFilter, error) {
	var it models.EnnoblementFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "villageID":
			var err error
			it.VillageID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "villageIDNEQ":
			var err error
			it.VillageIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerID":
			var err error
			it.NewOwnerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerIDNEQ":
			var err error
			it.NewOwnerIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerTribeID":
			var err error
			it.NewOwnerTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerTribeIDNEQ":
			var err error
			it.NewOwnerTribeIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerID":
			var err error
			it.OldOwnerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerIDNEQ":
			var err error
			it.OldOwnerIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerTribeID":
			var err error
			it.OldOwnerTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerTribeIDNEQ":
			var err error
			it.OldOwnerTribeIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAt":
			var err error
			it.EnnobledAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAtGT":
			var err error
			it.EnnobledAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAtGTE":
			var err error
			it.EnnobledAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAtLT":
			var err error
			it.EnnobledAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAtLTE":
			var err error
			it.EnnobledAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputLangVersionFilter(ctx context.Context, obj interface{}) (models.LangVersionFilter, error) {
	var it models.LangVersionFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "tag":
			var err error
			it.Tag, err = ec.unmarshalOLanguageTag2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTagᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tagNEQ":
			var err error
			it.TagNEQ, err = ec.unmarshalOLanguageTag2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTagᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "host":
			var err error
			it.Host, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "hostNEQ":
			var err error
			it.HostNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "hostMATCH":
			var err error
			it.HostMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "hostIEQ":
			var err error
			it.HostIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPlayerFilter(ctx context.Context, obj interface{}) (models.PlayerFilter, error) {
	var it models.PlayerFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "id":
			var err error
			it.ID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idNEQ":
			var err error
			it.IdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "exists":
			var err error
			it.Exists, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error
			it.Name, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameNEQ":
			var err error
			it.NameNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMATCH":
			var err error
			it.NameMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameIEQ":
			var err error
			it.NameIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillages":
			var err error
			it.TotalVillages, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesGT":
			var err error
			it.TotalVillagesGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesGTE":
			var err error
			it.TotalVillagesGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesLT":
			var err error
			it.TotalVillagesLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesLTE":
			var err error
			it.TotalVillagesLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "points":
			var err error
			it.Points, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGT":
			var err error
			it.PointsGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGTE":
			var err error
			it.PointsGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLT":
			var err error
			it.PointsLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLTE":
			var err error
			it.PointsLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rank":
			var err error
			it.Rank, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankGT":
			var err error
			it.RankGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankGTE":
			var err error
			it.RankGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankLT":
			var err error
			it.RankLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankLTE":
			var err error
			it.RankLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAtt":
			var err error
			it.RankAtt, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttGT":
			var err error
			it.RankAttGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttGTE":
			var err error
			it.RankAttGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttLT":
			var err error
			it.RankAttLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttLTE":
			var err error
			it.RankAttLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAtt":
			var err error
			it.ScoreAtt, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttGT":
			var err error
			it.ScoreAttGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttGTE":
			var err error
			it.ScoreAttGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttLT":
			var err error
			it.ScoreAttLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttLTE":
			var err error
			it.ScoreAttLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDef":
			var err error
			it.RankDef, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefGT":
			var err error
			it.RankDefGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefGTE":
			var err error
			it.RankDefGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefLT":
			var err error
			it.RankDefLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefLTE":
			var err error
			it.RankDefLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDef":
			var err error
			it.ScoreDef, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefGT":
			var err error
			it.ScoreDefGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefGTE":
			var err error
			it.ScoreDefGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefLT":
			var err error
			it.ScoreDefLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefLTE":
			var err error
			it.ScoreDefLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSup":
			var err error
			it.RankSup, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSupGT":
			var err error
			it.RankSupGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSupGTE":
			var err error
			it.RankSupGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSupLT":
			var err error
			it.RankSupLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSupLTE":
			var err error
			it.RankSupLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSup":
			var err error
			it.ScoreSup, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSupGT":
			var err error
			it.ScoreSupGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSupGTE":
			var err error
			it.ScoreSupGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSupLT":
			var err error
			it.ScoreSupLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSupLTE":
			var err error
			it.ScoreSupLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotal":
			var err error
			it.RankTotal, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalGT":
			var err error
			it.RankTotalGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalGTE":
			var err error
			it.RankTotalGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalLT":
			var err error
			it.RankTotalLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalLTE":
			var err error
			it.RankTotalLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotal":
			var err error
			it.ScoreTotal, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalGT":
			var err error
			it.ScoreTotalGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalGTE":
			var err error
			it.ScoreTotalGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalLT":
			var err error
			it.ScoreTotalLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalLTE":
			var err error
			it.ScoreTotalLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowth":
			var err error
			it.DailyGrowth, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowthGT":
			var err error
			it.DailyGrowthGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowthGTE":
			var err error
			it.DailyGrowthGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowthLT":
			var err error
			it.DailyGrowthLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowthLTE":
			var err error
			it.DailyGrowthLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAt":
			var err error
			it.JoinedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAtGT":
			var err error
			it.JoinedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAtGTE":
			var err error
			it.JoinedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAtLT":
			var err error
			it.JoinedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAtLTE":
			var err error
			it.JoinedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAt":
			var err error
			it.DeletedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtGT":
			var err error
			it.DeletedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtGTE":
			var err error
			it.DeletedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtLT":
			var err error
			it.DeletedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtLTE":
			var err error
			it.DeletedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeID":
			var err error
			it.TribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeFilter":
			var err error
			it.TribeFilter, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPlayerHistoryFilter(ctx context.Context, obj interface{}) (models.PlayerHistoryFilter, error) {
	var it models.PlayerHistoryFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "playerID":
			var err error
			it.PlayerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerIDNEQ":
			var err error
			it.PlayerIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDate":
			var err error
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputServerFilter(ctx context.Context, obj interface{}) (models.ServerFilter, error) {
	var it models.ServerFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "key":
			var err error
			it.Key, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "keyNEQ":
			var err error
			it.KeyNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "keyMATCH":
			var err error
			it.KeyMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "keyIEQ":
			var err error
			it.KeyIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "status":
			var err error
			it.Status, err = ec.unmarshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatusᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "statusNEQ":
			var err error
			it.StatusNEQ, err = ec.unmarshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatusᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "langVersionTag":
			var err error
			it.LangVersionTag, err = ec.unmarshalOLanguageTag2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTagᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "langVersionTagNEQ":
			var err error
			it.LangVersionTagNEQ, err = ec.unmarshalOLanguageTag2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTagᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputServerStatsFilter(ctx context.Context, obj interface{}) (models.ServerStatsFilter, error) {
	var it models.ServerStatsFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "createDate":
			var err error
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTribeChangeFilter(ctx context.Context, obj interface{}) (models.TribeChangeFilter, error) {
	var it models.TribeChangeFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "playerID":
			var err error
			it.PlayerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerIDNEQ":
			var err error
			it.PlayerIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldTribeID":
			var err error
			it.OldTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldTribeIDNEQ":
			var err error
			it.OldTribeIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newTribeID":
			var err error
			it.NewTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newTribeIDNEQ":
			var err error
			it.NewTribeIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error
			it.CreatedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtGT":
			var err error
			it.CreatedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtGTE":
			var err error
			it.CreatedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtLT":
			var err error
			it.CreatedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtLTE":
			var err error
			it.CreatedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTribeFilter(ctx context.Context, obj interface{}) (models.TribeFilter, error) {
	var it models.TribeFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "id":
			var err error
			it.ID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idNEQ":
			var err error
			it.IdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "exists":
			var err error
			it.Exists, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "tag":
			var err error
			it.Tag, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tagNEQ":
			var err error
			it.TagNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tagMATCH":
			var err error
			it.TagMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "tagIEQ":
			var err error
			it.TagIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error
			it.Name, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameNEQ":
			var err error
			it.NameNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMATCH":
			var err error
			it.NameMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameIEQ":
			var err error
			it.NameIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembers":
			var err error
			it.TotalMembers, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembersGT":
			var err error
			it.TotalMembersGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembersGTE":
			var err error
			it.TotalMembersGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembersLT":
			var err error
			it.TotalMembersLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembersLTE":
			var err error
			it.TotalMembersLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillages":
			var err error
			it.TotalVillages, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesGT":
			var err error
			it.TotalVillagesGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesGTE":
			var err error
			it.TotalVillagesGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesLT":
			var err error
			it.TotalVillagesLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesLTE":
			var err error
			it.TotalVillagesLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "points":
			var err error
			it.Points, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGT":
			var err error
			it.PointsGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGTE":
			var err error
			it.PointsGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLT":
			var err error
			it.PointsLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLTE":
			var err error
			it.PointsLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPoints":
			var err error
			it.AllPoints, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPointsGT":
			var err error
			it.AllPointsGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPointsGTE":
			var err error
			it.AllPointsGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPointsLT":
			var err error
			it.AllPointsLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPointsLTE":
			var err error
			it.AllPointsLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rank":
			var err error
			it.Rank, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankGT":
			var err error
			it.RankGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankGTE":
			var err error
			it.RankGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankLT":
			var err error
			it.RankLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankLTE":
			var err error
			it.RankLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAtt":
			var err error
			it.RankAtt, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttGT":
			var err error
			it.RankAttGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttGTE":
			var err error
			it.RankAttGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttLT":
			var err error
			it.RankAttLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttLTE":
			var err error
			it.RankAttLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAtt":
			var err error
			it.ScoreAtt, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttGT":
			var err error
			it.ScoreAttGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttGTE":
			var err error
			it.ScoreAttGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttLT":
			var err error
			it.ScoreAttLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttLTE":
			var err error
			it.ScoreAttLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDef":
			var err error
			it.RankDef, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefGT":
			var err error
			it.RankDefGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefGTE":
			var err error
			it.RankDefGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefLT":
			var err error
			it.RankDefLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefLTE":
			var err error
			it.RankDefLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDef":
			var err error
			it.ScoreDef, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefGT":
			var err error
			it.ScoreDefGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefGTE":
			var err error
			it.ScoreDefGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefLT":
			var err error
			it.ScoreDefLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefLTE":
			var err error
			it.ScoreDefLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotal":
			var err error
			it.RankTotal, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalGT":
			var err error
			it.RankTotalGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalGTE":
			var err error
			it.RankTotalGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalLT":
			var err error
			it.RankTotalLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalLTE":
			var err error
			it.RankTotalLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotal":
			var err error
			it.ScoreTotal, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalGT":
			var err error
			it.ScoreTotalGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalGTE":
			var err error
			it.ScoreTotalGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalLT":
			var err error
			it.ScoreTotalLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalLTE":
			var err error
			it.ScoreTotalLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominance":
			var err error
			it.Dominance, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominanceGT":
			var err error
			it.DominanceGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominanceGTE":
			var err error
			it.DominanceGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominanceLT":
			var err error
			it.DominanceLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominanceLTE":
			var err error
			it.DominanceLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error
			it.CreatedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtGT":
			var err error
			it.CreatedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtGTE":
			var err error
			it.CreatedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtLT":
			var err error
			it.CreatedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtLTE":
			var err error
			it.CreatedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAt":
			var err error
			it.DeletedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtGT":
			var err error
			it.DeletedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtGTE":
			var err error
			it.DeletedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtLT":
			var err error
			it.DeletedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtLTE":
			var err error
			it.DeletedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTribeHistoryFilter(ctx context.Context, obj interface{}) (models.TribeHistoryFilter, error) {
	var it models.TribeHistoryFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "tribeID":
			var err error
			it.TribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeIDNEQ":
			var err error
			it.TribeIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDate":
			var err error
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputVillageFilter(ctx context.Context, obj interface{}) (models.VillageFilter, error) {
	var it models.VillageFilter
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "id":
			var err error
			it.ID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idNEQ":
			var err error
			it.IdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error
			it.Name, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameNEQ":
			var err error
			it.NameNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMATCH":
			var err error
			it.NameMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameIEQ":
			var err error
			it.NameIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "points":
			var err error
			it.Points, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGT":
			var err error
			it.PointsGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGTE":
			var err error
			it.PointsGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLT":
			var err error
			it.PointsLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLTE":
			var err error
			it.PointsLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "xGT":
			var err error
			it.XGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "xGTE":
			var err error
			it.XGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "xLT":
			var err error
			it.XLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "xLTE":
			var err error
			it.XLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "yGT":
			var err error
			it.YGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "yGTE":
			var err error
			it.YGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "yLT":
			var err error
			it.YLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "yLTE":
			var err error
			it.YLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonus":
			var err error
			it.Bonus, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonusGT":
			var err error
			it.BonusGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonusGTE":
			var err error
			it.BonusGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonusLT":
			var err error
			it.BonusLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonusLTE":
			var err error
			it.BonusLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerID":
			var err error
			it.PlayerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerFilter":
			var err error
			it.PlayerFilter, err = ec.unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "offset":
			var err error
			it.Offset, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "limit":
			var err error
			it.Limit, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "sort":
			var err error
			it.Sort, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

// endregion **************************** input.gotpl *****************************

// region    ************************** interface.gotpl ***************************

// endregion ************************** interface.gotpl ***************************

// region    **************************** object.gotpl ****************************

var buildingImplementors = []string{"Building"}

func (ec *executionContext) _Building(ctx context.Context, sel ast.SelectionSet, obj *models.Building) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, buildingImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Building")
		case "maxLevel":
			out.Values[i] = ec._Building_maxLevel(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "minLevel":
			out.Values[i] = ec._Building_minLevel(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "wood":
			out.Values[i] = ec._Building_wood(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "stone":
			out.Values[i] = ec._Building_stone(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "iron":
			out.Values[i] = ec._Building_iron(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "pop":
			out.Values[i] = ec._Building_pop(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "woodFactor":
			out.Values[i] = ec._Building_woodFactor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "stoneFactor":
			out.Values[i] = ec._Building_stoneFactor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "ironFactor":
			out.Values[i] = ec._Building_ironFactor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "popFactor":
			out.Values[i] = ec._Building_popFactor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "buildTime":
			out.Values[i] = ec._Building_buildTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "buildTimeFactor":
			out.Values[i] = ec._Building_buildTimeFactor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var buildingConfigImplementors = []string{"BuildingConfig"}

func (ec *executionContext) _BuildingConfig(ctx context.Context, sel ast.SelectionSet, obj *models.BuildingConfig) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, buildingConfigImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BuildingConfig")
		case "main":
			out.Values[i] = ec._BuildingConfig_main(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "barracks":
			out.Values[i] = ec._BuildingConfig_barracks(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "stable":
			out.Values[i] = ec._BuildingConfig_stable(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "garage":
			out.Values[i] = ec._BuildingConfig_garage(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "watchtower":
			out.Values[i] = ec._BuildingConfig_watchtower(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "snob":
			out.Values[i] = ec._BuildingConfig_snob(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "smith":
			out.Values[i] = ec._BuildingConfig_smith(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "place":
			out.Values[i] = ec._BuildingConfig_place(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "statue":
			out.Values[i] = ec._BuildingConfig_statue(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "market":
			out.Values[i] = ec._BuildingConfig_market(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "wood":
			out.Values[i] = ec._BuildingConfig_wood(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "stone":
			out.Values[i] = ec._BuildingConfig_stone(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "iron":
			out.Values[i] = ec._BuildingConfig_iron(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "farm":
			out.Values[i] = ec._BuildingConfig_farm(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "storage":
			out.Values[i] = ec._BuildingConfig_storage(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "hide":
			out.Values[i] = ec._BuildingConfig_hide(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "wall":
			out.Values[i] = ec._BuildingConfig_wall(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var dailyPlayerStatsImplementors = []string{"DailyPlayerStats"}

func (ec *executionContext) _DailyPlayerStats(ctx context.Context, sel ast.SelectionSet, obj *DailyPlayerStats) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, dailyPlayerStatsImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DailyPlayerStats")
		case "total":
			out.Values[i] = ec._DailyPlayerStats_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "items":
			out.Values[i] = ec._DailyPlayerStats_items(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var dailyPlayerStatsRecordImplementors = []string{"DailyPlayerStatsRecord"}

func (ec *executionContext) _DailyPlayerStatsRecord(ctx context.Context, sel ast.SelectionSet, obj *models.DailyPlayerStats) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, dailyPlayerStatsRecordImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DailyPlayerStatsRecord")
		case "player":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._DailyPlayerStatsRecord_player(ctx, field, obj)
				return res
			})
		case "villages":
			out.Values[i] = ec._DailyPlayerStatsRecord_villages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "points":
			out.Values[i] = ec._DailyPlayerStatsRecord_points(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rank":
			out.Values[i] = ec._DailyPlayerStatsRecord_rank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankAtt":
			out.Values[i] = ec._DailyPlayerStatsRecord_rankAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreAtt":
			out.Values[i] = ec._DailyPlayerStatsRecord_scoreAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankDef":
			out.Values[i] = ec._DailyPlayerStatsRecord_rankDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreDef":
			out.Values[i] = ec._DailyPlayerStatsRecord_scoreDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankSup":
			out.Values[i] = ec._DailyPlayerStatsRecord_rankSup(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreSup":
			out.Values[i] = ec._DailyPlayerStatsRecord_scoreSup(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankTotal":
			out.Values[i] = ec._DailyPlayerStatsRecord_rankTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreTotal":
			out.Values[i] = ec._DailyPlayerStatsRecord_scoreTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "createDate":
			out.Values[i] = ec._DailyPlayerStatsRecord_createDate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var dailyTribeStatsImplementors = []string{"DailyTribeStats"}

func (ec *executionContext) _DailyTribeStats(ctx context.Context, sel ast.SelectionSet, obj *DailyTribeStats) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, dailyTribeStatsImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DailyTribeStats")
		case "total":
			out.Values[i] = ec._DailyTribeStats_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "items":
			out.Values[i] = ec._DailyTribeStats_items(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var dailyTribeStatsRecordImplementors = []string{"DailyTribeStatsRecord"}

func (ec *executionContext) _DailyTribeStatsRecord(ctx context.Context, sel ast.SelectionSet, obj *models.DailyTribeStats) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, dailyTribeStatsRecordImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DailyTribeStatsRecord")
		case "tribe":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._DailyTribeStatsRecord_tribe(ctx, field, obj)
				return res
			})
		case "members":
			out.Values[i] = ec._DailyTribeStatsRecord_members(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "villages":
			out.Values[i] = ec._DailyTribeStatsRecord_villages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "points":
			out.Values[i] = ec._DailyTribeStatsRecord_points(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "allPoints":
			out.Values[i] = ec._DailyTribeStatsRecord_allPoints(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rank":
			out.Values[i] = ec._DailyTribeStatsRecord_rank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankAtt":
			out.Values[i] = ec._DailyTribeStatsRecord_rankAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreAtt":
			out.Values[i] = ec._DailyTribeStatsRecord_scoreAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankDef":
			out.Values[i] = ec._DailyTribeStatsRecord_rankDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreDef":
			out.Values[i] = ec._DailyTribeStatsRecord_scoreDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankTotal":
			out.Values[i] = ec._DailyTribeStatsRecord_rankTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreTotal":
			out.Values[i] = ec._DailyTribeStatsRecord_scoreTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "dominance":
			out.Values[i] = ec._DailyTribeStatsRecord_dominance(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "createDate":
			out.Values[i] = ec._DailyTribeStatsRecord_createDate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var ennoblementImplementors = []string{"Ennoblement"}

func (ec *executionContext) _Ennoblement(ctx context.Context, sel ast.SelectionSet, obj *models.Ennoblement) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, ennoblementImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Ennoblement")
		case "village":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Ennoblement_village(ctx, field, obj)
				return res
			})
		case "newOwner":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Ennoblement_newOwner(ctx, field, obj)
				return res
			})
		case "newOwnerTribe":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Ennoblement_newOwnerTribe(ctx, field, obj)
				return res
			})
		case "oldOwner":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Ennoblement_oldOwner(ctx, field, obj)
				return res
			})
		case "oldOwnerTribe":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Ennoblement_oldOwnerTribe(ctx, field, obj)
				return res
			})
		case "ennobledAt":
			out.Values[i] = ec._Ennoblement_ennobledAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var ennoblementListImplementors = []string{"EnnoblementList"}

func (ec *executionContext) _EnnoblementList(ctx context.Context, sel ast.SelectionSet, obj *EnnoblementList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, ennoblementListImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("EnnoblementList")
		case "items":
			out.Values[i] = ec._EnnoblementList_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._EnnoblementList_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var langVersionImplementors = []string{"LangVersion"}

func (ec *executionContext) _LangVersion(ctx context.Context, sel ast.SelectionSet, obj *models.LangVersion) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, langVersionImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("LangVersion")
		case "tag":
			out.Values[i] = ec._LangVersion_tag(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._LangVersion_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "host":
			out.Values[i] = ec._LangVersion_host(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "timezone":
			out.Values[i] = ec._LangVersion_timezone(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var langVersionListImplementors = []string{"LangVersionList"}

func (ec *executionContext) _LangVersionList(ctx context.Context, sel ast.SelectionSet, obj *LangVersionList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, langVersionListImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("LangVersionList")
		case "items":
			out.Values[i] = ec._LangVersionList_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._LangVersionList_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var liveEnnoblementImplementors = []string{"LiveEnnoblement"}

func (ec *executionContext) _LiveEnnoblement(ctx context.Context, sel ast.SelectionSet, obj *models.LiveEnnoblement) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, liveEnnoblementImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("LiveEnnoblement")
		case "village":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._LiveEnnoblement_village(ctx, field, obj)
				return res
			})
		case "newOwner":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._LiveEnnoblement_newOwner(ctx, field, obj)
				return res
			})
		case "oldOwner":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._LiveEnnoblement_oldOwner(ctx, field, obj)
				return res
			})
		case "ennobledAt":
			out.Values[i] = ec._LiveEnnoblement_ennobledAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var playerImplementors = []string{"Player"}

func (ec *executionContext) _Player(ctx context.Context, sel ast.SelectionSet, obj *models.Player) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, playerImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Player")
		case "id":
			out.Values[i] = ec._Player_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "name":
			out.Values[i] = ec._Player_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "totalVillages":
			out.Values[i] = ec._Player_totalVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "points":
			out.Values[i] = ec._Player_points(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rank":
			out.Values[i] = ec._Player_rank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "exists":
			out.Values[i] = ec._Player_exists(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankAtt":
			out.Values[i] = ec._Player_rankAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreAtt":
			out.Values[i] = ec._Player_scoreAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankDef":
			out.Values[i] = ec._Player_rankDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreDef":
			out.Values[i] = ec._Player_scoreDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankSup":
			out.Values[i] = ec._Player_rankSup(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreSup":
			out.Values[i] = ec._Player_scoreSup(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankTotal":
			out.Values[i] = ec._Player_rankTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreTotal":
			out.Values[i] = ec._Player_scoreTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "dailyGrowth":
			out.Values[i] = ec._Player_dailyGrowth(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "bestRank":
			out.Values[i] = ec._Player_bestRank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "bestRankAt":
			out.Values[i] = ec._Player_bestRankAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "mostPoints":
			out.Values[i] = ec._Player_mostPoints(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "mostPointsAt":
			out.Values[i] = ec._Player_mostPointsAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "mostVillages":
			out.Values[i] = ec._Player_mostVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "mostVillagesAt":
			out.Values[i] = ec._Player_mostVillagesAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "joinedAt":
			out.Values[i] = ec._Player_joinedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "deletedAt":
			out.Values[i] = ec._Player_deletedAt(ctx, field, obj)
		case "tribe":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Player_tribe(ctx, field, obj)
				return res
			})
		case "servers":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Player_servers(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "nameChanges":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Player_nameChanges(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var playerHistoryImplementors = []string{"PlayerHistory"}

func (ec *executionContext) _PlayerHistory(ctx context.Context, sel ast.SelectionSet, obj *PlayerHistory) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, playerHistoryImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PlayerHistory")
		case "total":
			out.Values[i] = ec._PlayerHistory_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "items":
			out.Values[i] = ec._PlayerHistory_items(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var playerHistoryRecordImplementors = []string{"PlayerHistoryRecord"}

func (ec *executionContext) _PlayerHistoryRecord(ctx context.Context, sel ast.SelectionSet, obj *models.PlayerHistory) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, playerHistoryRecordImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PlayerHistoryRecord")
		case "player":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._PlayerHistoryRecord_player(ctx, field, obj)
				return res
			})
		case "totalVillages":
			out.Values[i] = ec._PlayerHistoryRecord_totalVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "points":
			out.Values[i] = ec._PlayerHistoryRecord_points(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rank":
			out.Values[i] = ec._PlayerHistoryRecord_rank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankAtt":
			out.Values[i] = ec._PlayerHistoryRecord_rankAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreAtt":
			out.Values[i] = ec._PlayerHistoryRecord_scoreAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankDef":
			out.Values[i] = ec._PlayerHistoryRecord_rankDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreDef":
			out.Values[i] = ec._PlayerHistoryRecord_scoreDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankSup":
			out.Values[i] = ec._PlayerHistoryRecord_rankSup(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreSup":
			out.Values[i] = ec._PlayerHistoryRecord_scoreSup(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankTotal":
			out.Values[i] = ec._PlayerHistoryRecord_rankTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreTotal":
			out.Values[i] = ec._PlayerHistoryRecord_scoreTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "tribe":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._PlayerHistoryRecord_tribe(ctx, field, obj)
				return res
			})
		case "createDate":
			out.Values[i] = ec._PlayerHistoryRecord_createDate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var playerListImplementors = []string{"PlayerList"}

func (ec *executionContext) _PlayerList(ctx context.Context, sel ast.SelectionSet, obj *PlayerList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, playerListImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PlayerList")
		case "items":
			out.Values[i] = ec._PlayerList_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._PlayerList_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var playerNameChangeImplementors = []string{"PlayerNameChange"}

func (ec *executionContext) _PlayerNameChange(ctx context.Context, sel ast.SelectionSet, obj *models.PlayerNameChange) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, playerNameChangeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PlayerNameChange")
		case "oldName":
			out.Values[i] = ec._PlayerNameChange_oldName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "newName":
			out.Values[i] = ec._PlayerNameChange_newName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "changeDate":
			out.Values[i] = ec._PlayerNameChange_changeDate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var queryImplementors = []string{"Query"}

func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)

	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
		Object: "Query",
	})

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Query")
		case "dailyPlayerStats":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_dailyPlayerStats(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "dailyTribeStats":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_dailyTribeStats(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "ennoblements":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_ennoblements(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "langVersions":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_langVersions(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "langVersion":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_langVersion(ctx, field)
				return res
			})
		case "liveEnnoblements":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_liveEnnoblements(ctx, field)
				return res
			})
		case "players":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_players(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "player":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_player(ctx, field)
				return res
			})
		case "playerHistory":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_playerHistory(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "servers":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_servers(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "server":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_server(ctx, field)
				return res
			})
		case "serverStats":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_serverStats(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "tribes":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_tribes(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "tribe":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_tribe(ctx, field)
				return res
			})
		case "tribeChanges":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_tribeChanges(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "tribeHistory":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_tribeHistory(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "villages":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_villages(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "village":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_village(ctx, field)
				return res
			})
		case "__type":
			out.Values[i] = ec._Query___type(ctx, field)
		case "__schema":
			out.Values[i] = ec._Query___schema(ctx, field)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverImplementors = []string{"Server"}

func (ec *executionContext) _Server(ctx context.Context, sel ast.SelectionSet, obj *models.Server) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Server")
		case "key":
			out.Values[i] = ec._Server_key(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "status":
			out.Values[i] = ec._Server_status(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "numberOfPlayers":
			out.Values[i] = ec._Server_numberOfPlayers(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "numberOfTribes":
			out.Values[i] = ec._Server_numberOfTribes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "numberOfVillages":
			out.Values[i] = ec._Server_numberOfVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "langVersion":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Server_langVersion(ctx, field, obj)
				return res
			})
		case "config":
			out.Values[i] = ec._Server_config(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "unitConfig":
			out.Values[i] = ec._Server_unitConfig(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "buildingConfig":
			out.Values[i] = ec._Server_buildingConfig(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "dataUpdatedAt":
			out.Values[i] = ec._Server_dataUpdatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "historyUpdatedAt":
			out.Values[i] = ec._Server_historyUpdatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "statsUpdatedAt":
			out.Values[i] = ec._Server_statsUpdatedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigImplementors = []string{"ServerConfig"}

func (ec *executionContext) _ServerConfig(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfig) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfig")
		case "speed":
			out.Values[i] = ec._ServerConfig_speed(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "unitSpeed":
			out.Values[i] = ec._ServerConfig_unitSpeed(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "moral":
			out.Values[i] = ec._ServerConfig_moral(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "build":
			out.Values[i] = ec._ServerConfig_build(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "misc":
			out.Values[i] = ec._ServerConfig_misc(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "commands":
			out.Values[i] = ec._ServerConfig_commands(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "newbie":
			out.Values[i] = ec._ServerConfig_newbie(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "game":
			out.Values[i] = ec._ServerConfig_game(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "buildings":
			out.Values[i] = ec._ServerConfig_buildings(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "snob":
			out.Values[i] = ec._ServerConfig_snob(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "ally":
			out.Values[i] = ec._ServerConfig_ally(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "coord":
			out.Values[i] = ec._ServerConfig_coord(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "sitter":
			out.Values[i] = ec._ServerConfig_sitter(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "sleep":
			out.Values[i] = ec._ServerConfig_sleep(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "night":
			out.Values[i] = ec._ServerConfig_night(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "win":
			out.Values[i] = ec._ServerConfig_win(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigAllyImplementors = []string{"ServerConfigAlly"}

func (ec *executionContext) _ServerConfigAlly(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigAlly) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigAllyImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigAlly")
		case "noHarm":
			out.Values[i] = ec._ServerConfigAlly_noHarm(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "noOtherSupport":
			out.Values[i] = ec._ServerConfigAlly_noOtherSupport(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "allytimeSupport":
			out.Values[i] = ec._ServerConfigAlly_allytimeSupport(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "noLeave":
			out.Values[i] = ec._ServerConfigAlly_noLeave(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "noJoin":
			out.Values[i] = ec._ServerConfigAlly_noJoin(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "limit":
			out.Values[i] = ec._ServerConfigAlly_limit(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "fixedAllies":
			out.Values[i] = ec._ServerConfigAlly_fixedAllies(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "pointsMemberCount":
			out.Values[i] = ec._ServerConfigAlly_pointsMemberCount(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "warsMemberRequirement":
			out.Values[i] = ec._ServerConfigAlly_warsMemberRequirement(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "warsPointsRequirement":
			out.Values[i] = ec._ServerConfigAlly_warsPointsRequirement(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "warsAutoacceptDays":
			out.Values[i] = ec._ServerConfigAlly_warsAutoacceptDays(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "levels":
			out.Values[i] = ec._ServerConfigAlly_levels(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "xpRequirements":
			out.Values[i] = ec._ServerConfigAlly_xpRequirements(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigBuildImplementors = []string{"ServerConfigBuild"}

func (ec *executionContext) _ServerConfigBuild(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigBuild) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigBuildImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigBuild")
		case "destroy":
			out.Values[i] = ec._ServerConfigBuild_destroy(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigBuildingsImplementors = []string{"ServerConfigBuildings"}

func (ec *executionContext) _ServerConfigBuildings(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigBuildings) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigBuildingsImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigBuildings")
		case "customMain":
			out.Values[i] = ec._ServerConfigBuildings_customMain(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customFarm":
			out.Values[i] = ec._ServerConfigBuildings_customFarm(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customStorage":
			out.Values[i] = ec._ServerConfigBuildings_customStorage(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customPlace":
			out.Values[i] = ec._ServerConfigBuildings_customPlace(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customBarracks":
			out.Values[i] = ec._ServerConfigBuildings_customBarracks(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customChurch":
			out.Values[i] = ec._ServerConfigBuildings_customChurch(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customSmith":
			out.Values[i] = ec._ServerConfigBuildings_customSmith(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customWood":
			out.Values[i] = ec._ServerConfigBuildings_customWood(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customStone":
			out.Values[i] = ec._ServerConfigBuildings_customStone(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customIron":
			out.Values[i] = ec._ServerConfigBuildings_customIron(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customMarket":
			out.Values[i] = ec._ServerConfigBuildings_customMarket(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customStable":
			out.Values[i] = ec._ServerConfigBuildings_customStable(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customWall":
			out.Values[i] = ec._ServerConfigBuildings_customWall(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customGarage":
			out.Values[i] = ec._ServerConfigBuildings_customGarage(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customHide":
			out.Values[i] = ec._ServerConfigBuildings_customHide(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customSnob":
			out.Values[i] = ec._ServerConfigBuildings_customSnob(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customStatue":
			out.Values[i] = ec._ServerConfigBuildings_customStatue(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "customWatchtower":
			out.Values[i] = ec._ServerConfigBuildings_customWatchtower(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigCommandsImplementors = []string{"ServerConfigCommands"}

func (ec *executionContext) _ServerConfigCommands(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigCommands) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigCommandsImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigCommands")
		case "millisArrival":
			out.Values[i] = ec._ServerConfigCommands_millisArrival(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "commandCancelTime":
			out.Values[i] = ec._ServerConfigCommands_commandCancelTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigCoordImplementors = []string{"ServerConfigCoord"}

func (ec *executionContext) _ServerConfigCoord(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigCoord) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigCoordImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigCoord")
		case "mapSize":
			out.Values[i] = ec._ServerConfigCoord_mapSize(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "func":
			out.Values[i] = ec._ServerConfigCoord_func(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "emptyVillages":
			out.Values[i] = ec._ServerConfigCoord_emptyVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "bonusVillages":
			out.Values[i] = ec._ServerConfigCoord_bonusVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "bonusNew":
			out.Values[i] = ec._ServerConfigCoord_bonusNew(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "inner":
			out.Values[i] = ec._ServerConfigCoord_inner(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "selectStart":
			out.Values[i] = ec._ServerConfigCoord_selectStart(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "villageMoveWait":
			out.Values[i] = ec._ServerConfigCoord_villageMoveWait(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "nobleRestart":
			out.Values[i] = ec._ServerConfigCoord_nobleRestart(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "startVillages":
			out.Values[i] = ec._ServerConfigCoord_startVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigGameImplementors = []string{"ServerConfigGame"}

func (ec *executionContext) _ServerConfigGame(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigGame) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigGameImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigGame")
		case "buildtimeFormula":
			out.Values[i] = ec._ServerConfigGame_buildtimeFormula(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "knight":
			out.Values[i] = ec._ServerConfigGame_knight(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "knightNewItems":
			out.Values[i] = ec._ServerConfigGame_knightNewItems(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "archer":
			out.Values[i] = ec._ServerConfigGame_archer(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "tech":
			out.Values[i] = ec._ServerConfigGame_tech(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "farmLimit":
			out.Values[i] = ec._ServerConfigGame_farmLimit(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "church":
			out.Values[i] = ec._ServerConfigGame_church(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "watchtower":
			out.Values[i] = ec._ServerConfigGame_watchtower(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "stronghold":
			out.Values[i] = ec._ServerConfigGame_stronghold(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "fakeLimit":
			out.Values[i] = ec._ServerConfigGame_fakeLimit(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "barbarianRise":
			out.Values[i] = ec._ServerConfigGame_barbarianRise(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "barbarianShrink":
			out.Values[i] = ec._ServerConfigGame_barbarianShrink(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "barbarianMaxPoints":
			out.Values[i] = ec._ServerConfigGame_barbarianMaxPoints(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "hauls":
			out.Values[i] = ec._ServerConfigGame_hauls(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "haulsBase":
			out.Values[i] = ec._ServerConfigGame_haulsBase(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "haulsMax":
			out.Values[i] = ec._ServerConfigGame_haulsMax(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "baseProduction":
			out.Values[i] = ec._ServerConfigGame_baseProduction(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "event":
			out.Values[i] = ec._ServerConfigGame_event(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "suppressEvents":
			out.Values[i] = ec._ServerConfigGame_suppressEvents(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigMiscImplementors = []string{"ServerConfigMisc"}

func (ec *executionContext) _ServerConfigMisc(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigMisc) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigMiscImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigMisc")
		case "killRanking":
			out.Values[i] = ec._ServerConfigMisc_killRanking(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "tutorial":
			out.Values[i] = ec._ServerConfigMisc_tutorial(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "tradeCancelTime":
			out.Values[i] = ec._ServerConfigMisc_tradeCancelTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigNewbieImplementors = []string{"ServerConfigNewbie"}

func (ec *executionContext) _ServerConfigNewbie(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigNewbie) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigNewbieImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigNewbie")
		case "days":
			out.Values[i] = ec._ServerConfigNewbie_days(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "ratioDays":
			out.Values[i] = ec._ServerConfigNewbie_ratioDays(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "ratio":
			out.Values[i] = ec._ServerConfigNewbie_ratio(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "removeNewbieVillages":
			out.Values[i] = ec._ServerConfigNewbie_removeNewbieVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigNightImplementors = []string{"ServerConfigNight"}

func (ec *executionContext) _ServerConfigNight(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigNight) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigNightImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigNight")
		case "active":
			out.Values[i] = ec._ServerConfigNight_active(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "startHour":
			out.Values[i] = ec._ServerConfigNight_startHour(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "endHour":
			out.Values[i] = ec._ServerConfigNight_endHour(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "defFactor":
			out.Values[i] = ec._ServerConfigNight_defFactor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigSitterImplementors = []string{"ServerConfigSitter"}

func (ec *executionContext) _ServerConfigSitter(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigSitter) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigSitterImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigSitter")
		case "allow":
			out.Values[i] = ec._ServerConfigSitter_allow(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigSleepImplementors = []string{"ServerConfigSleep"}

func (ec *executionContext) _ServerConfigSleep(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigSleep) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigSleepImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigSleep")
		case "active":
			out.Values[i] = ec._ServerConfigSleep_active(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "delay":
			out.Values[i] = ec._ServerConfigSleep_delay(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "min":
			out.Values[i] = ec._ServerConfigSleep_min(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "max":
			out.Values[i] = ec._ServerConfigSleep_max(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "minAwake":
			out.Values[i] = ec._ServerConfigSleep_minAwake(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "maxAwake":
			out.Values[i] = ec._ServerConfigSleep_maxAwake(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "warnTime":
			out.Values[i] = ec._ServerConfigSleep_warnTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigSnobImplementors = []string{"ServerConfigSnob"}

func (ec *executionContext) _ServerConfigSnob(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigSnob) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigSnobImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigSnob")
		case "gold":
			out.Values[i] = ec._ServerConfigSnob_gold(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "cheapRebuild":
			out.Values[i] = ec._ServerConfigSnob_cheapRebuild(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "rise":
			out.Values[i] = ec._ServerConfigSnob_rise(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "maxDist":
			out.Values[i] = ec._ServerConfigSnob_maxDist(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "factor":
			out.Values[i] = ec._ServerConfigSnob_factor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "coinWood":
			out.Values[i] = ec._ServerConfigSnob_coinWood(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "coinStone":
			out.Values[i] = ec._ServerConfigSnob_coinStone(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "coinIron":
			out.Values[i] = ec._ServerConfigSnob_coinIron(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "noBarbConquer":
			out.Values[i] = ec._ServerConfigSnob_noBarbConquer(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverConfigWinImplementors = []string{"ServerConfigWin"}

func (ec *executionContext) _ServerConfigWin(ctx context.Context, sel ast.SelectionSet, obj *models.ServerConfigWin) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverConfigWinImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerConfigWin")
		case "check":
			out.Values[i] = ec._ServerConfigWin_check(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverListImplementors = []string{"ServerList"}

func (ec *executionContext) _ServerList(ctx context.Context, sel ast.SelectionSet, obj *ServerList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverListImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerList")
		case "items":
			out.Values[i] = ec._ServerList_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._ServerList_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverStatsImplementors = []string{"ServerStats"}

func (ec *executionContext) _ServerStats(ctx context.Context, sel ast.SelectionSet, obj *ServerStats) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverStatsImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerStats")
		case "items":
			out.Values[i] = ec._ServerStats_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._ServerStats_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var serverStatsRecordImplementors = []string{"ServerStatsRecord"}

func (ec *executionContext) _ServerStatsRecord(ctx context.Context, sel ast.SelectionSet, obj *models.ServerStats) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, serverStatsRecordImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ServerStatsRecord")
		case "activePlayers":
			out.Values[i] = ec._ServerStatsRecord_activePlayers(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "inactivePlayers":
			out.Values[i] = ec._ServerStatsRecord_inactivePlayers(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "players":
			out.Values[i] = ec._ServerStatsRecord_players(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "activeTribes":
			out.Values[i] = ec._ServerStatsRecord_activeTribes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "inactiveTribes":
			out.Values[i] = ec._ServerStatsRecord_inactiveTribes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "tribes":
			out.Values[i] = ec._ServerStatsRecord_tribes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "bonusVillages":
			out.Values[i] = ec._ServerStatsRecord_bonusVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "barbarianVillages":
			out.Values[i] = ec._ServerStatsRecord_barbarianVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "playerVillages":
			out.Values[i] = ec._ServerStatsRecord_playerVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "villages":
			out.Values[i] = ec._ServerStatsRecord_villages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "createDate":
			out.Values[i] = ec._ServerStatsRecord_createDate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var tribeImplementors = []string{"Tribe"}

func (ec *executionContext) _Tribe(ctx context.Context, sel ast.SelectionSet, obj *models.Tribe) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, tribeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Tribe")
		case "id":
			out.Values[i] = ec._Tribe_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._Tribe_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "tag":
			out.Values[i] = ec._Tribe_tag(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "totalMembers":
			out.Values[i] = ec._Tribe_totalMembers(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "totalVillages":
			out.Values[i] = ec._Tribe_totalVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "points":
			out.Values[i] = ec._Tribe_points(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "allPoints":
			out.Values[i] = ec._Tribe_allPoints(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "rank":
			out.Values[i] = ec._Tribe_rank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "exists":
			out.Values[i] = ec._Tribe_exists(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "rankAtt":
			out.Values[i] = ec._Tribe_rankAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "scoreAtt":
			out.Values[i] = ec._Tribe_scoreAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "rankDef":
			out.Values[i] = ec._Tribe_rankDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "scoreDef":
			out.Values[i] = ec._Tribe_scoreDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "rankTotal":
			out.Values[i] = ec._Tribe_rankTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "scoreTotal":
			out.Values[i] = ec._Tribe_scoreTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "dominance":
			out.Values[i] = ec._Tribe_dominance(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "bestRank":
			out.Values[i] = ec._Tribe_bestRank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "bestRankAt":
			out.Values[i] = ec._Tribe_bestRankAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mostPoints":
			out.Values[i] = ec._Tribe_mostPoints(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mostPointsAt":
			out.Values[i] = ec._Tribe_mostPointsAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mostVillages":
			out.Values[i] = ec._Tribe_mostVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mostVillagesAt":
			out.Values[i] = ec._Tribe_mostVillagesAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "createdAt":
			out.Values[i] = ec._Tribe_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deletedAt":
			out.Values[i] = ec._Tribe_deletedAt(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var tribeChangeRecordImplementors = []string{"TribeChangeRecord"}

func (ec *executionContext) _TribeChangeRecord(ctx context.Context, sel ast.SelectionSet, obj *models.TribeChange) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, tribeChangeRecordImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TribeChangeRecord")
		case "player":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TribeChangeRecord_player(ctx, field, obj)
				return res
			})
		case "oldTribe":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TribeChangeRecord_oldTribe(ctx, field, obj)
				return res
			})
		case "newTribe":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TribeChangeRecord_newTribe(ctx, field, obj)
				return res
			})
		case "createdAt":
			out.Values[i] = ec._TribeChangeRecord_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var tribeChangesImplementors = []string{"TribeChanges"}

func (ec *executionContext) _TribeChanges(ctx context.Context, sel ast.SelectionSet, obj *TribeChanges) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, tribeChangesImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TribeChanges")
		case "total":
			out.Values[i] = ec._TribeChanges_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "items":
			out.Values[i] = ec._TribeChanges_items(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var tribeHistoryImplementors = []string{"TribeHistory"}

func (ec *executionContext) _TribeHistory(ctx context.Context, sel ast.SelectionSet, obj *TribeHistory) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, tribeHistoryImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TribeHistory")
		case "total":
			out.Values[i] = ec._TribeHistory_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "items":
			out.Values[i] = ec._TribeHistory_items(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var tribeHistoryRecordImplementors = []string{"TribeHistoryRecord"}

func (ec *executionContext) _TribeHistoryRecord(ctx context.Context, sel ast.SelectionSet, obj *models.TribeHistory) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, tribeHistoryRecordImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TribeHistoryRecord")
		case "tribe":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TribeHistoryRecord_tribe(ctx, field, obj)
				return res
			})
		case "totalVillages":
			out.Values[i] = ec._TribeHistoryRecord_totalVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "totalMembers":
			out.Values[i] = ec._TribeHistoryRecord_totalMembers(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "points":
			out.Values[i] = ec._TribeHistoryRecord_points(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "allPoints":
			out.Values[i] = ec._TribeHistoryRecord_allPoints(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rank":
			out.Values[i] = ec._TribeHistoryRecord_rank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "dominance":
			out.Values[i] = ec._TribeHistoryRecord_dominance(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankAtt":
			out.Values[i] = ec._TribeHistoryRecord_rankAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreAtt":
			out.Values[i] = ec._TribeHistoryRecord_scoreAtt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankDef":
			out.Values[i] = ec._TribeHistoryRecord_rankDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreDef":
			out.Values[i] = ec._TribeHistoryRecord_scoreDef(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "rankTotal":
			out.Values[i] = ec._TribeHistoryRecord_rankTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "scoreTotal":
			out.Values[i] = ec._TribeHistoryRecord_scoreTotal(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "createDate":
			out.Values[i] = ec._TribeHistoryRecord_createDate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var tribeListImplementors = []string{"TribeList"}

func (ec *executionContext) _TribeList(ctx context.Context, sel ast.SelectionSet, obj *TribeList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, tribeListImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TribeList")
		case "items":
			out.Values[i] = ec._TribeList_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._TribeList_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var unitImplementors = []string{"Unit"}

func (ec *executionContext) _Unit(ctx context.Context, sel ast.SelectionSet, obj *models.Unit) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, unitImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Unit")
		case "buildTime":
			out.Values[i] = ec._Unit_buildTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "pop":
			out.Values[i] = ec._Unit_pop(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "speed":
			out.Values[i] = ec._Unit_speed(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "attack":
			out.Values[i] = ec._Unit_attack(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "defense":
			out.Values[i] = ec._Unit_defense(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "defenseCavalry":
			out.Values[i] = ec._Unit_defenseCavalry(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "defenseArcher":
			out.Values[i] = ec._Unit_defenseArcher(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "carry":
			out.Values[i] = ec._Unit_carry(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var unitConfigImplementors = []string{"UnitConfig"}

func (ec *executionContext) _UnitConfig(ctx context.Context, sel ast.SelectionSet, obj *models.UnitConfig) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, unitConfigImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UnitConfig")
		case "spear":
			out.Values[i] = ec._UnitConfig_spear(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "sword":
			out.Values[i] = ec._UnitConfig_sword(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "axe":
			out.Values[i] = ec._UnitConfig_axe(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "archer":
			out.Values[i] = ec._UnitConfig_archer(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "spy":
			out.Values[i] = ec._UnitConfig_spy(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "light":
			out.Values[i] = ec._UnitConfig_light(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "marcher":
			out.Values[i] = ec._UnitConfig_marcher(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "heavy":
			out.Values[i] = ec._UnitConfig_heavy(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "ram":
			out.Values[i] = ec._UnitConfig_ram(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "catapult":
			out.Values[i] = ec._UnitConfig_catapult(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "knight":
			out.Values[i] = ec._UnitConfig_knight(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "snob":
			out.Values[i] = ec._UnitConfig_snob(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "militia":
			out.Values[i] = ec._UnitConfig_militia(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var villageImplementors = []string{"Village"}

func (ec *executionContext) _Village(ctx context.Context, sel ast.SelectionSet, obj *models.Village) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, villageImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Village")
		case "id":
			out.Values[i] = ec._Village_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "name":
			out.Values[i] = ec._Village_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "points":
			out.Values[i] = ec._Village_points(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "x":
			out.Values[i] = ec._Village_x(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "y":
			out.Values[i] = ec._Village_y(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "bonus":
			out.Values[i] = ec._Village_bonus(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "player":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Village_player(ctx, field, obj)
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var villageListImplementors = []string{"VillageList"}

func (ec *executionContext) _VillageList(ctx context.Context, sel ast.SelectionSet, obj *VillageList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, villageListImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("VillageList")
		case "items":
			out.Values[i] = ec._VillageList_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._VillageList_total(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __DirectiveImplementors = []string{"__Directive"}

func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Directive")
		case "name":
			out.Values[i] = ec.___Directive_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___Directive_description(ctx, field, obj)
		case "locations":
			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "args":
			out.Values[i] = ec.___Directive_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __EnumValueImplementors = []string{"__EnumValue"}

func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__EnumValue")
		case "name":
			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
		case "isDeprecated":
			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __FieldImplementors = []string{"__Field"}

func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Field")
		case "name":
			out.Values[i] = ec.___Field_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___Field_description(ctx, field, obj)
		case "args":
			out.Values[i] = ec.___Field_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "type":
			out.Values[i] = ec.___Field_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "isDeprecated":
			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __InputValueImplementors = []string{"__InputValue"}

func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__InputValue")
		case "name":
			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
		case "type":
			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "defaultValue":
			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __SchemaImplementors = []string{"__Schema"}

func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Schema")
		case "types":
			out.Values[i] = ec.___Schema_types(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "queryType":
			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mutationType":
			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
		case "subscriptionType":
			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
		case "directives":
			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __TypeImplementors = []string{"__Type"}

func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Type")
		case "kind":
			out.Values[i] = ec.___Type_kind(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec.___Type_name(ctx, field, obj)
		case "description":
			out.Values[i] = ec.___Type_description(ctx, field, obj)
		case "fields":
			out.Values[i] = ec.___Type_fields(ctx, field, obj)
		case "interfaces":
			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
		case "possibleTypes":
			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
		case "enumValues":
			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
		case "inputFields":
			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
		case "ofType":
			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

// endregion **************************** object.gotpl ****************************

// region    ***************************** type.gotpl *****************************

func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
	return graphql.UnmarshalBoolean(v)
}

func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
	res := graphql.MarshalBoolean(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalNBoolean2bool(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalNBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec.marshalNBoolean2bool(ctx, sel, *v)
}

func (ec *executionContext) marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuilding(ctx context.Context, sel ast.SelectionSet, v models.Building) graphql.Marshaler {
	return ec._Building(ctx, sel, &v)
}

func (ec *executionContext) marshalNBuildingConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐBuildingConfig(ctx context.Context, sel ast.SelectionSet, v models.BuildingConfig) graphql.Marshaler {
	return ec._BuildingConfig(ctx, sel, &v)
}

func (ec *executionContext) marshalNDailyPlayerStats2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐDailyPlayerStats(ctx context.Context, sel ast.SelectionSet, v DailyPlayerStats) graphql.Marshaler {
	return ec._DailyPlayerStats(ctx, sel, &v)
}

func (ec *executionContext) marshalNDailyPlayerStats2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐDailyPlayerStats(ctx context.Context, sel ast.SelectionSet, v *DailyPlayerStats) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._DailyPlayerStats(ctx, sel, v)
}

func (ec *executionContext) marshalNDailyPlayerStatsRecord2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyPlayerStats(ctx context.Context, sel ast.SelectionSet, v models.DailyPlayerStats) graphql.Marshaler {
	return ec._DailyPlayerStatsRecord(ctx, sel, &v)
}

func (ec *executionContext) marshalNDailyPlayerStatsRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyPlayerStats(ctx context.Context, sel ast.SelectionSet, v *models.DailyPlayerStats) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._DailyPlayerStatsRecord(ctx, sel, v)
}

func (ec *executionContext) marshalNDailyTribeStats2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐDailyTribeStats(ctx context.Context, sel ast.SelectionSet, v DailyTribeStats) graphql.Marshaler {
	return ec._DailyTribeStats(ctx, sel, &v)
}

func (ec *executionContext) marshalNDailyTribeStats2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐDailyTribeStats(ctx context.Context, sel ast.SelectionSet, v *DailyTribeStats) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._DailyTribeStats(ctx, sel, v)
}

func (ec *executionContext) marshalNDailyTribeStatsRecord2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyTribeStats(ctx context.Context, sel ast.SelectionSet, v models.DailyTribeStats) graphql.Marshaler {
	return ec._DailyTribeStatsRecord(ctx, sel, &v)
}

func (ec *executionContext) marshalNDailyTribeStatsRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyTribeStats(ctx context.Context, sel ast.SelectionSet, v *models.DailyTribeStats) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._DailyTribeStatsRecord(ctx, sel, v)
}

func (ec *executionContext) marshalNEnnoblement2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblement(ctx context.Context, sel ast.SelectionSet, v models.Ennoblement) graphql.Marshaler {
	return ec._Ennoblement(ctx, sel, &v)
}

func (ec *executionContext) marshalNEnnoblement2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblement(ctx context.Context, sel ast.SelectionSet, v *models.Ennoblement) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Ennoblement(ctx, sel, v)
}

func (ec *executionContext) marshalNEnnoblementList2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐEnnoblementList(ctx context.Context, sel ast.SelectionSet, v EnnoblementList) graphql.Marshaler {
	return ec._EnnoblementList(ctx, sel, &v)
}

func (ec *executionContext) marshalNEnnoblementList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐEnnoblementList(ctx context.Context, sel ast.SelectionSet, v *EnnoblementList) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._EnnoblementList(ctx, sel, v)
}

func (ec *executionContext) unmarshalNFloat2float64(ctx context.Context, v interface{}) (float64, error) {
	return graphql.UnmarshalFloat(v)
}

func (ec *executionContext) marshalNFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
	res := graphql.MarshalFloat(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
	return graphql.UnmarshalInt(v)
}

func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
	res := graphql.MarshalInt(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNLangVersion2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersion(ctx context.Context, sel ast.SelectionSet, v models.LangVersion) graphql.Marshaler {
	return ec._LangVersion(ctx, sel, &v)
}

func (ec *executionContext) marshalNLangVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersion(ctx context.Context, sel ast.SelectionSet, v *models.LangVersion) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._LangVersion(ctx, sel, v)
}

func (ec *executionContext) marshalNLangVersionList2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐLangVersionList(ctx context.Context, sel ast.SelectionSet, v LangVersionList) graphql.Marshaler {
	return ec._LangVersionList(ctx, sel, &v)
}

func (ec *executionContext) marshalNLangVersionList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐLangVersionList(ctx context.Context, sel ast.SelectionSet, v *LangVersionList) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._LangVersionList(ctx, sel, v)
}

func (ec *executionContext) unmarshalNLanguageTag2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTag(ctx context.Context, v interface{}) (models.LanguageTag, error) {
	var res models.LanguageTag
	return res, res.UnmarshalGQL(v)
}

func (ec *executionContext) marshalNLanguageTag2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTag(ctx context.Context, sel ast.SelectionSet, v models.LanguageTag) graphql.Marshaler {
	return v
}

func (ec *executionContext) marshalNLiveEnnoblement2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLiveEnnoblement(ctx context.Context, sel ast.SelectionSet, v models.LiveEnnoblement) graphql.Marshaler {
	return ec._LiveEnnoblement(ctx, sel, &v)
}

func (ec *executionContext) marshalNLiveEnnoblement2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLiveEnnoblement(ctx context.Context, sel ast.SelectionSet, v *models.LiveEnnoblement) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._LiveEnnoblement(ctx, sel, v)
}

func (ec *executionContext) marshalNPlayer2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx context.Context, sel ast.SelectionSet, v models.Player) graphql.Marshaler {
	return ec._Player(ctx, sel, &v)
}

func (ec *executionContext) marshalNPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx context.Context, sel ast.SelectionSet, v *models.Player) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Player(ctx, sel, v)
}

func (ec *executionContext) marshalNPlayerHistory2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐPlayerHistory(ctx context.Context, sel ast.SelectionSet, v PlayerHistory) graphql.Marshaler {
	return ec._PlayerHistory(ctx, sel, &v)
}

func (ec *executionContext) marshalNPlayerHistory2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐPlayerHistory(ctx context.Context, sel ast.SelectionSet, v *PlayerHistory) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._PlayerHistory(ctx, sel, v)
}

func (ec *executionContext) marshalNPlayerHistoryRecord2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerHistory(ctx context.Context, sel ast.SelectionSet, v models.PlayerHistory) graphql.Marshaler {
	return ec._PlayerHistoryRecord(ctx, sel, &v)
}

func (ec *executionContext) marshalNPlayerHistoryRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerHistory(ctx context.Context, sel ast.SelectionSet, v *models.PlayerHistory) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._PlayerHistoryRecord(ctx, sel, v)
}

func (ec *executionContext) marshalNPlayerList2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐPlayerList(ctx context.Context, sel ast.SelectionSet, v PlayerList) graphql.Marshaler {
	return ec._PlayerList(ctx, sel, &v)
}

func (ec *executionContext) marshalNPlayerList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐPlayerList(ctx context.Context, sel ast.SelectionSet, v *PlayerList) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._PlayerList(ctx, sel, v)
}

func (ec *executionContext) marshalNPlayerNameChange2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerNameChange(ctx context.Context, sel ast.SelectionSet, v models.PlayerNameChange) graphql.Marshaler {
	return ec._PlayerNameChange(ctx, sel, &v)
}

func (ec *executionContext) marshalNPlayerNameChange2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerNameChangeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.PlayerNameChange) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNPlayerNameChange2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerNameChange(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNPlayerNameChange2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerNameChange(ctx context.Context, sel ast.SelectionSet, v *models.PlayerNameChange) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._PlayerNameChange(ctx, sel, v)
}

func (ec *executionContext) marshalNServer2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServer(ctx context.Context, sel ast.SelectionSet, v models.Server) graphql.Marshaler {
	return ec._Server(ctx, sel, &v)
}

func (ec *executionContext) marshalNServer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServer(ctx context.Context, sel ast.SelectionSet, v *models.Server) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Server(ctx, sel, v)
}

func (ec *executionContext) marshalNServerConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfig(ctx context.Context, sel ast.SelectionSet, v models.ServerConfig) graphql.Marshaler {
	return ec._ServerConfig(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigAlly2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigAlly(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigAlly) graphql.Marshaler {
	return ec._ServerConfigAlly(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigBuild2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigBuild(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigBuild) graphql.Marshaler {
	return ec._ServerConfigBuild(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigBuildings2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigBuildings(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigBuildings) graphql.Marshaler {
	return ec._ServerConfigBuildings(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigCommands2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigCommands(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigCommands) graphql.Marshaler {
	return ec._ServerConfigCommands(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigCoord2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigCoord(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigCoord) graphql.Marshaler {
	return ec._ServerConfigCoord(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigGame2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigGame(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigGame) graphql.Marshaler {
	return ec._ServerConfigGame(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigMisc2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigMisc(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigMisc) graphql.Marshaler {
	return ec._ServerConfigMisc(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigNewbie2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigNewbie(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigNewbie) graphql.Marshaler {
	return ec._ServerConfigNewbie(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigNight2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigNight(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigNight) graphql.Marshaler {
	return ec._ServerConfigNight(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigSitter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigSitter(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigSitter) graphql.Marshaler {
	return ec._ServerConfigSitter(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigSleep2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigSleep(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigSleep) graphql.Marshaler {
	return ec._ServerConfigSleep(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigSnob2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigSnob(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigSnob) graphql.Marshaler {
	return ec._ServerConfigSnob(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigWin2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerConfigWin(ctx context.Context, sel ast.SelectionSet, v models.ServerConfigWin) graphql.Marshaler {
	return ec._ServerConfigWin(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerList2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐServerList(ctx context.Context, sel ast.SelectionSet, v ServerList) graphql.Marshaler {
	return ec._ServerList(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐServerList(ctx context.Context, sel ast.SelectionSet, v *ServerList) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._ServerList(ctx, sel, v)
}

func (ec *executionContext) marshalNServerStats2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐServerStats(ctx context.Context, sel ast.SelectionSet, v ServerStats) graphql.Marshaler {
	return ec._ServerStats(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerStats2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐServerStats(ctx context.Context, sel ast.SelectionSet, v *ServerStats) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._ServerStats(ctx, sel, v)
}

func (ec *executionContext) marshalNServerStatsRecord2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStats(ctx context.Context, sel ast.SelectionSet, v models.ServerStats) graphql.Marshaler {
	return ec._ServerStatsRecord(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerStatsRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStats(ctx context.Context, sel ast.SelectionSet, v *models.ServerStats) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._ServerStatsRecord(ctx, sel, v)
}

func (ec *executionContext) unmarshalNServerStatus2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatus(ctx context.Context, v interface{}) (models.ServerStatus, error) {
	var res models.ServerStatus
	return res, res.UnmarshalGQL(v)
}

func (ec *executionContext) marshalNServerStatus2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatus(ctx context.Context, sel ast.SelectionSet, v models.ServerStatus) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
	return graphql.UnmarshalString(v)
}

func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
	}

	return ret
}

func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
	return graphql.UnmarshalTime(v)
}

func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
	res := graphql.MarshalTime(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNTribe2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx context.Context, sel ast.SelectionSet, v models.Tribe) graphql.Marshaler {
	return ec._Tribe(ctx, sel, &v)
}

func (ec *executionContext) marshalNTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx context.Context, sel ast.SelectionSet, v *models.Tribe) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Tribe(ctx, sel, v)
}

func (ec *executionContext) marshalNTribeChangeRecord2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChange(ctx context.Context, sel ast.SelectionSet, v models.TribeChange) graphql.Marshaler {
	return ec._TribeChangeRecord(ctx, sel, &v)
}

func (ec *executionContext) marshalNTribeChangeRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChange(ctx context.Context, sel ast.SelectionSet, v *models.TribeChange) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._TribeChangeRecord(ctx, sel, v)
}

func (ec *executionContext) marshalNTribeChanges2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeChanges(ctx context.Context, sel ast.SelectionSet, v TribeChanges) graphql.Marshaler {
	return ec._TribeChanges(ctx, sel, &v)
}

func (ec *executionContext) marshalNTribeChanges2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeChanges(ctx context.Context, sel ast.SelectionSet, v *TribeChanges) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._TribeChanges(ctx, sel, v)
}

func (ec *executionContext) marshalNTribeHistory2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeHistory(ctx context.Context, sel ast.SelectionSet, v TribeHistory) graphql.Marshaler {
	return ec._TribeHistory(ctx, sel, &v)
}

func (ec *executionContext) marshalNTribeHistory2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeHistory(ctx context.Context, sel ast.SelectionSet, v *TribeHistory) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._TribeHistory(ctx, sel, v)
}

func (ec *executionContext) marshalNTribeHistoryRecord2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeHistory(ctx context.Context, sel ast.SelectionSet, v models.TribeHistory) graphql.Marshaler {
	return ec._TribeHistoryRecord(ctx, sel, &v)
}

func (ec *executionContext) marshalNTribeHistoryRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeHistory(ctx context.Context, sel ast.SelectionSet, v *models.TribeHistory) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._TribeHistoryRecord(ctx, sel, v)
}

func (ec *executionContext) marshalNTribeList2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeList(ctx context.Context, sel ast.SelectionSet, v TribeList) graphql.Marshaler {
	return ec._TribeList(ctx, sel, &v)
}

func (ec *executionContext) marshalNTribeList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeList(ctx context.Context, sel ast.SelectionSet, v *TribeList) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._TribeList(ctx, sel, v)
}

func (ec *executionContext) marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnit(ctx context.Context, sel ast.SelectionSet, v models.Unit) graphql.Marshaler {
	return ec._Unit(ctx, sel, &v)
}

func (ec *executionContext) marshalNUnitConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐUnitConfig(ctx context.Context, sel ast.SelectionSet, v models.UnitConfig) graphql.Marshaler {
	return ec._UnitConfig(ctx, sel, &v)
}

func (ec *executionContext) marshalNVillage2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillage(ctx context.Context, sel ast.SelectionSet, v models.Village) graphql.Marshaler {
	return ec._Village(ctx, sel, &v)
}

func (ec *executionContext) marshalNVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillage(ctx context.Context, sel ast.SelectionSet, v *models.Village) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Village(ctx, sel, v)
}

func (ec *executionContext) marshalNVillageList2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐVillageList(ctx context.Context, sel ast.SelectionSet, v VillageList) graphql.Marshaler {
	return ec._VillageList(ctx, sel, &v)
}

func (ec *executionContext) marshalNVillageList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐVillageList(ctx context.Context, sel ast.SelectionSet, v *VillageList) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._VillageList(ctx, sel, v)
}

func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
	return ec.___Directive(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
	return graphql.UnmarshalString(v)
}

func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
	return ec.___EnumValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
	return ec.___Field(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
	return ec.___InputValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
	return ec.___Type(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
	return graphql.UnmarshalString(v)
}

func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
	return graphql.UnmarshalBoolean(v)
}

func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
	return graphql.MarshalBoolean(v)
}

func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOBoolean2bool(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.marshalOBoolean2bool(ctx, sel, *v)
}

func (ec *executionContext) unmarshalODailyPlayerStatsFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyPlayerStatsFilter(ctx context.Context, v interface{}) (models.DailyPlayerStatsFilter, error) {
	return ec.unmarshalInputDailyPlayerStatsFilter(ctx, v)
}

func (ec *executionContext) unmarshalODailyPlayerStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyPlayerStatsFilter(ctx context.Context, v interface{}) (*models.DailyPlayerStatsFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalODailyPlayerStatsFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyPlayerStatsFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalODailyPlayerStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyPlayerStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.DailyPlayerStats) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNDailyPlayerStatsRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyPlayerStats(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalODailyTribeStatsFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyTribeStatsFilter(ctx context.Context, v interface{}) (models.DailyTribeStatsFilter, error) {
	return ec.unmarshalInputDailyTribeStatsFilter(ctx, v)
}

func (ec *executionContext) unmarshalODailyTribeStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyTribeStatsFilter(ctx context.Context, v interface{}) (*models.DailyTribeStatsFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalODailyTribeStatsFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyTribeStatsFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalODailyTribeStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyTribeStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.DailyTribeStats) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNDailyTribeStatsRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐDailyTribeStats(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOEnnoblement2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblementᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Ennoblement) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNEnnoblement2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblement(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOEnnoblementFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblementFilter(ctx context.Context, v interface{}) (models.EnnoblementFilter, error) {
	return ec.unmarshalInputEnnoblementFilter(ctx, v)
}

func (ec *executionContext) unmarshalOEnnoblementFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblementFilter(ctx context.Context, v interface{}) (*models.EnnoblementFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOEnnoblementFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblementFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
	return graphql.UnmarshalInt(v)
}

func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
	return graphql.MarshalInt(v)
}

func (ec *executionContext) unmarshalOInt2ᚕintᚄ(ctx context.Context, v interface{}) ([]int, error) {
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]int, len(vSlice))
	for i := range vSlice {
		res[i], err = ec.unmarshalNInt2int(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOInt2ᚕintᚄ(ctx context.Context, sel ast.SelectionSet, v []int) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNInt2int(ctx, sel, v[i])
	}

	return ret
}

func (ec *executionContext) marshalOLangVersion2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersion(ctx context.Context, sel ast.SelectionSet, v models.LangVersion) graphql.Marshaler {
	return ec._LangVersion(ctx, sel, &v)
}

func (ec *executionContext) marshalOLangVersion2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersionᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LangVersion) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNLangVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersion(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOLangVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersion(ctx context.Context, sel ast.SelectionSet, v *models.LangVersion) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._LangVersion(ctx, sel, v)
}

func (ec *executionContext) unmarshalOLangVersionFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersionFilter(ctx context.Context, v interface{}) (models.LangVersionFilter, error) {
	return ec.unmarshalInputLangVersionFilter(ctx, v)
}

func (ec *executionContext) unmarshalOLangVersionFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersionFilter(ctx context.Context, v interface{}) (*models.LangVersionFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOLangVersionFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLangVersionFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) unmarshalOLanguageTag2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTagᚄ(ctx context.Context, v interface{}) ([]models.LanguageTag, error) {
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]models.LanguageTag, len(vSlice))
	for i := range vSlice {
		res[i], err = ec.unmarshalNLanguageTag2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTag(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOLanguageTag2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTagᚄ(ctx context.Context, sel ast.SelectionSet, v []models.LanguageTag) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNLanguageTag2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLanguageTag(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOLiveEnnoblement2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLiveEnnoblementᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LiveEnnoblement) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNLiveEnnoblement2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐLiveEnnoblement(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOPlayer2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx context.Context, sel ast.SelectionSet, v models.Player) graphql.Marshaler {
	return ec._Player(ctx, sel, &v)
}

func (ec *executionContext) marshalOPlayer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Player) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx context.Context, sel ast.SelectionSet, v *models.Player) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Player(ctx, sel, v)
}

func (ec *executionContext) unmarshalOPlayerFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerFilter(ctx context.Context, v interface{}) (models.PlayerFilter, error) {
	return ec.unmarshalInputPlayerFilter(ctx, v)
}

func (ec *executionContext) unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerFilter(ctx context.Context, v interface{}) (*models.PlayerFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOPlayerFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) unmarshalOPlayerHistoryFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerHistoryFilter(ctx context.Context, v interface{}) (models.PlayerHistoryFilter, error) {
	return ec.unmarshalInputPlayerHistoryFilter(ctx, v)
}

func (ec *executionContext) unmarshalOPlayerHistoryFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerHistoryFilter(ctx context.Context, v interface{}) (*models.PlayerHistoryFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOPlayerHistoryFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerHistoryFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalOPlayerHistoryRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerHistoryᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.PlayerHistory) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNPlayerHistoryRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerHistory(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOServer2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServer(ctx context.Context, sel ast.SelectionSet, v models.Server) graphql.Marshaler {
	return ec._Server(ctx, sel, &v)
}

func (ec *executionContext) marshalOServer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Server) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNServer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServer(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOServer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServer(ctx context.Context, sel ast.SelectionSet, v *models.Server) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Server(ctx, sel, v)
}

func (ec *executionContext) unmarshalOServerFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerFilter(ctx context.Context, v interface{}) (models.ServerFilter, error) {
	return ec.unmarshalInputServerFilter(ctx, v)
}

func (ec *executionContext) unmarshalOServerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerFilter(ctx context.Context, v interface{}) (*models.ServerFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOServerFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) unmarshalOServerStatsFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatsFilter(ctx context.Context, v interface{}) (models.ServerStatsFilter, error) {
	return ec.unmarshalInputServerStatsFilter(ctx, v)
}

func (ec *executionContext) unmarshalOServerStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatsFilter(ctx context.Context, v interface{}) (*models.ServerStatsFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOServerStatsFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatsFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalOServerStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.ServerStats) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNServerStatsRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStats(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatusᚄ(ctx context.Context, v interface{}) ([]models.ServerStatus, error) {
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]models.ServerStatus, len(vSlice))
	for i := range vSlice {
		res[i], err = ec.unmarshalNServerStatus2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatus(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatusᚄ(ctx context.Context, sel ast.SelectionSet, v []models.ServerStatus) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNServerStatus2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatus(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
	return graphql.UnmarshalString(v)
}

func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	return graphql.MarshalString(v)
}

func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
	}

	return ret
}

func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOString2string(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.marshalOString2string(ctx, sel, *v)
}

func (ec *executionContext) unmarshalOTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
	return graphql.UnmarshalTime(v)
}

func (ec *executionContext) marshalOTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
	return graphql.MarshalTime(v)
}

func (ec *executionContext) marshalOTribe2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx context.Context, sel ast.SelectionSet, v models.Tribe) graphql.Marshaler {
	return ec._Tribe(ctx, sel, &v)
}

func (ec *executionContext) marshalOTribe2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Tribe) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx context.Context, sel ast.SelectionSet, v *models.Tribe) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Tribe(ctx, sel, v)
}

func (ec *executionContext) unmarshalOTribeChangeFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeFilter(ctx context.Context, v interface{}) (models.TribeChangeFilter, error) {
	return ec.unmarshalInputTribeChangeFilter(ctx, v)
}

func (ec *executionContext) unmarshalOTribeChangeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeFilter(ctx context.Context, v interface{}) (*models.TribeChangeFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOTribeChangeFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalOTribeChangeRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TribeChange) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNTribeChangeRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChange(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOTribeFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeFilter(ctx context.Context, v interface{}) (models.TribeFilter, error) {
	return ec.unmarshalInputTribeFilter(ctx, v)
}

func (ec *executionContext) unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeFilter(ctx context.Context, v interface{}) (*models.TribeFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOTribeFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) unmarshalOTribeHistoryFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeHistoryFilter(ctx context.Context, v interface{}) (models.TribeHistoryFilter, error) {
	return ec.unmarshalInputTribeHistoryFilter(ctx, v)
}

func (ec *executionContext) unmarshalOTribeHistoryFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeHistoryFilter(ctx context.Context, v interface{}) (*models.TribeHistoryFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOTribeHistoryFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeHistoryFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalOTribeHistoryRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeHistoryᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TribeHistory) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNTribeHistoryRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeHistory(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOVillage2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillage(ctx context.Context, sel ast.SelectionSet, v models.Village) graphql.Marshaler {
	return ec._Village(ctx, sel, &v)
}

func (ec *executionContext) marshalOVillage2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillageᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Village) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillage(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillage(ctx context.Context, sel ast.SelectionSet, v *models.Village) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Village(ctx, sel, v)
}

func (ec *executionContext) unmarshalOVillageFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillageFilter(ctx context.Context, v interface{}) (models.VillageFilter, error) {
	return ec.unmarshalInputVillageFilter(ctx, v)
}

func (ec *executionContext) unmarshalOVillageFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillageFilter(ctx context.Context, v interface{}) (*models.VillageFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOVillageFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillageFilter(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
	return ec.___Schema(ctx, sel, &v)
}

func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.___Schema(ctx, sel, v)
}

func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
	return ec.___Type(ctx, sel, &v)
}

func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

// endregion ***************************** type.gotpl *****************************