api/graphql/generated/generated.go

// 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/tw/twmodel"
	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
	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
		ID         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
		ID         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
		ID            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
	}

	FoundPlayer struct {
		BestRank     func(childComplexity int) int
		ID           func(childComplexity int) int
		MostPoints   func(childComplexity int) int
		MostVillages func(childComplexity int) int
		Name         func(childComplexity int) int
		Server       func(childComplexity int) int
		TribeID      func(childComplexity int) int
		TribeTag     func(childComplexity int) int
	}

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

	FoundTribe struct {
		BestRank     func(childComplexity int) int
		ID           func(childComplexity int) int
		MostPoints   func(childComplexity int) int
		MostVillages func(childComplexity int) int
		Name         func(childComplexity int) int
		Server       func(childComplexity int) int
		Tag          func(childComplexity int) int
	}

	FoundTribeList struct {
		Items func(childComplexity int) int
		Total 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
		LastActivityAt 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
		ID            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 *twmodel.DailyPlayerStatsFilter, limit *int, offset *int, sort []string) int
		DailyTribeStats  func(childComplexity int, server string, filter *twmodel.DailyTribeStatsFilter, limit *int, offset *int, sort []string) int
		Ennoblements     func(childComplexity int, server string, filter *twmodel.EnnoblementFilter, limit *int, offset *int, sort []string) int
		Player           func(childComplexity int, server string, id int) int
		PlayerHistory    func(childComplexity int, server string, filter *twmodel.PlayerHistoryFilter, limit *int, offset *int, sort []string) int
		Players          func(childComplexity int, server string, filter *twmodel.PlayerFilter, limit *int, offset *int, sort []string) int
		SearchPlayer     func(childComplexity int, version string, name *string, id *int, limit *int, offset *int, sort []string) int
		SearchTribe      func(childComplexity int, version string, query string, limit *int, offset *int, sort []string) int
		Server           func(childComplexity int, key string) int
		ServerStats      func(childComplexity int, server string, filter *twmodel.ServerStatsFilter, limit *int, offset *int, sort []string) int
		Servers          func(childComplexity int, filter *twmodel.ServerFilter, limit *int, offset *int, sort []string) int
		Tribe            func(childComplexity int, server string, id int) int
		TribeChanges     func(childComplexity int, server string, filter *twmodel.TribeChangeFilter, limit *int, offset *int, sort []string) int
		TribeHistory     func(childComplexity int, server string, filter *twmodel.TribeHistoryFilter, limit *int, offset *int, sort []string) int
		Tribes           func(childComplexity int, server string, filter *twmodel.TribeFilter, limit *int, offset *int, sort []string) int
		Version          func(childComplexity int, code twmodel.VersionCode) int
		Versions         func(childComplexity int, filter *twmodel.VersionFilter, limit *int, offset *int, sort []string) int
		Village          func(childComplexity int, server string, id int) int
		Villages         func(childComplexity int, server string, filter *twmodel.VillageFilter, limit *int, offset *int, sort []string) 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
		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
		Version          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
		ID                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
		ID        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
		ID            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
	}

	Version struct {
		Code     func(childComplexity int) int
		Host     func(childComplexity int) int
		Name     func(childComplexity int) int
		Timezone func(childComplexity int) int
	}

	VersionList struct {
		Items func(childComplexity int) int
		Total 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 *twmodel.DailyPlayerStats) (*twmodel.Player, error)
}
type DailyTribeStatsRecordResolver interface {
	Tribe(ctx context.Context, obj *twmodel.DailyTribeStats) (*twmodel.Tribe, error)
}
type EnnoblementResolver interface {
	Village(ctx context.Context, obj *twmodel.Ennoblement) (*twmodel.Village, error)
	NewOwner(ctx context.Context, obj *twmodel.Ennoblement) (*twmodel.Player, error)
	NewOwnerTribe(ctx context.Context, obj *twmodel.Ennoblement) (*twmodel.Tribe, error)
	OldOwner(ctx context.Context, obj *twmodel.Ennoblement) (*twmodel.Player, error)
	OldOwnerTribe(ctx context.Context, obj *twmodel.Ennoblement) (*twmodel.Tribe, error)
}
type PlayerResolver interface {
	Tribe(ctx context.Context, obj *twmodel.Player) (*twmodel.Tribe, error)
	Servers(ctx context.Context, obj *twmodel.Player) ([]string, error)
	NameChanges(ctx context.Context, obj *twmodel.Player) ([]*twmodel.PlayerNameChange, error)
}
type PlayerHistoryRecordResolver interface {
	Player(ctx context.Context, obj *twmodel.PlayerHistory) (*twmodel.Player, error)

	Tribe(ctx context.Context, obj *twmodel.PlayerHistory) (*twmodel.Tribe, error)
}
type QueryResolver interface {
	DailyPlayerStats(ctx context.Context, server string, filter *twmodel.DailyPlayerStatsFilter, limit *int, offset *int, sort []string) (*DailyPlayerStats, error)
	DailyTribeStats(ctx context.Context, server string, filter *twmodel.DailyTribeStatsFilter, limit *int, offset *int, sort []string) (*DailyTribeStats, error)
	Ennoblements(ctx context.Context, server string, filter *twmodel.EnnoblementFilter, limit *int, offset *int, sort []string) (*EnnoblementList, error)
	Players(ctx context.Context, server string, filter *twmodel.PlayerFilter, limit *int, offset *int, sort []string) (*PlayerList, error)
	Player(ctx context.Context, server string, id int) (*twmodel.Player, error)
	SearchPlayer(ctx context.Context, version string, name *string, id *int, limit *int, offset *int, sort []string) (*FoundPlayerList, error)
	PlayerHistory(ctx context.Context, server string, filter *twmodel.PlayerHistoryFilter, limit *int, offset *int, sort []string) (*PlayerHistory, error)
	Servers(ctx context.Context, filter *twmodel.ServerFilter, limit *int, offset *int, sort []string) (*ServerList, error)
	Server(ctx context.Context, key string) (*twmodel.Server, error)
	ServerStats(ctx context.Context, server string, filter *twmodel.ServerStatsFilter, limit *int, offset *int, sort []string) (*ServerStats, error)
	Tribes(ctx context.Context, server string, filter *twmodel.TribeFilter, limit *int, offset *int, sort []string) (*TribeList, error)
	Tribe(ctx context.Context, server string, id int) (*twmodel.Tribe, error)
	SearchTribe(ctx context.Context, version string, query string, limit *int, offset *int, sort []string) (*FoundTribeList, error)
	TribeChanges(ctx context.Context, server string, filter *twmodel.TribeChangeFilter, limit *int, offset *int, sort []string) (*TribeChanges, error)
	TribeHistory(ctx context.Context, server string, filter *twmodel.TribeHistoryFilter, limit *int, offset *int, sort []string) (*TribeHistory, error)
	Versions(ctx context.Context, filter *twmodel.VersionFilter, limit *int, offset *int, sort []string) (*VersionList, error)
	Version(ctx context.Context, code twmodel.VersionCode) (*twmodel.Version, error)
	Villages(ctx context.Context, server string, filter *twmodel.VillageFilter, limit *int, offset *int, sort []string) (*VillageList, error)
	Village(ctx context.Context, server string, id int) (*twmodel.Village, error)
}
type ServerResolver interface {
	Version(ctx context.Context, obj *twmodel.Server) (*twmodel.Version, error)
}
type TribeChangeRecordResolver interface {
	Player(ctx context.Context, obj *twmodel.TribeChange) (*twmodel.Player, error)
	OldTribe(ctx context.Context, obj *twmodel.TribeChange) (*twmodel.Tribe, error)
	NewTribe(ctx context.Context, obj *twmodel.TribeChange) (*twmodel.Tribe, error)
}
type TribeHistoryRecordResolver interface {
	Tribe(ctx context.Context, obj *twmodel.TribeHistory) (*twmodel.Tribe, error)
}
type VillageResolver interface {
	Player(ctx context.Context, obj *twmodel.Village) (*twmodel.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.id":
		if e.complexity.DailyPlayerStatsRecord.ID == nil {
			break
		}

		return e.complexity.DailyPlayerStatsRecord.ID(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.id":
		if e.complexity.DailyTribeStatsRecord.ID == nil {
			break
		}

		return e.complexity.DailyTribeStatsRecord.ID(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.id":
		if e.complexity.Ennoblement.ID == nil {
			break
		}

		return e.complexity.Ennoblement.ID(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 "FoundPlayer.bestRank":
		if e.complexity.FoundPlayer.BestRank == nil {
			break
		}

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

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

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

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

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

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

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

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

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

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

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

	case "FoundPlayer.tribeID":
		if e.complexity.FoundPlayer.TribeID == nil {
			break
		}

		return e.complexity.FoundPlayer.TribeID(childComplexity), true

	case "FoundPlayer.tribeTag":
		if e.complexity.FoundPlayer.TribeTag == nil {
			break
		}

		return e.complexity.FoundPlayer.TribeTag(childComplexity), true

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		return e.complexity.FoundTribeList.Total(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.lastActivityAt":
		if e.complexity.Player.LastActivityAt == nil {
			break
		}

		return e.complexity.Player.LastActivityAt(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.id":
		if e.complexity.PlayerHistoryRecord.ID == nil {
			break
		}

		return e.complexity.PlayerHistoryRecord.ID(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"].(*twmodel.DailyPlayerStatsFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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"].(*twmodel.DailyTribeStatsFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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"].(*twmodel.EnnoblementFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]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"].(*twmodel.PlayerHistoryFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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"].(*twmodel.PlayerFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), true

	case "Query.searchPlayer":
		if e.complexity.Query.SearchPlayer == nil {
			break
		}

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

		return e.complexity.Query.SearchPlayer(childComplexity, args["version"].(string), args["name"].(*string), args["id"].(*int), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), true

	case "Query.searchTribe":
		if e.complexity.Query.SearchTribe == nil {
			break
		}

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

		return e.complexity.Query.SearchTribe(childComplexity, args["version"].(string), args["query"].(string), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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"].(*twmodel.ServerStatsFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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"].(*twmodel.ServerFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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"].(*twmodel.TribeChangeFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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"].(*twmodel.TribeHistoryFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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"].(*twmodel.TribeFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), true

	case "Query.version":
		if e.complexity.Query.Version == nil {
			break
		}

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

		return e.complexity.Query.Version(childComplexity, args["code"].(twmodel.VersionCode)), true

	case "Query.versions":
		if e.complexity.Query.Versions == nil {
			break
		}

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

		return e.complexity.Query.Versions(childComplexity, args["filter"].(*twmodel.VersionFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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"].(*twmodel.VillageFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string)), 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.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 "Server.version":
		if e.complexity.Server.Version == nil {
			break
		}

		return e.complexity.Server.Version(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.id":
		if e.complexity.ServerStatsRecord.ID == nil {
			break
		}

		return e.complexity.ServerStatsRecord.ID(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.id":
		if e.complexity.TribeChangeRecord.ID == nil {
			break
		}

		return e.complexity.TribeChangeRecord.ID(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.id":
		if e.complexity.TribeHistoryRecord.ID == nil {
			break
		}

		return e.complexity.TribeHistoryRecord.ID(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 "Version.code":
		if e.complexity.Version.Code == nil {
			break
		}

		return e.complexity.Version.Code(childComplexity), true

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

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

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

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

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

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

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

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

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

		return e.complexity.VersionList.Total(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{
	{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},
	{Name: "schema/daily_player_stats.graphql", Input: `type DailyPlayerStatsRecord {
  id: Int!
  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!]
  playerFilter: PlayerFilter

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

extend type Query {
  dailyPlayerStats(
    server: String!
    filter: DailyPlayerStatsFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): DailyPlayerStats!
}
`, BuiltIn: false},
	{Name: "schema/daily_tribe_stats.graphql", Input: `type DailyTribeStatsRecord {
  id: Int!
  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!]
  tribeFilter: TribeFilter

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

extend type Query {
  dailyTribeStats(
    server: String!
    filter: DailyTribeStatsFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): DailyTribeStats!
}
`, BuiltIn: false},
	{Name: "schema/directives.graphql", Input: `directive @goField(
  forceResolver: Boolean
  name: String
) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION`, BuiltIn: false},
	{Name: "schema/ennoblements.graphql", Input: `type Ennoblement {
  id: Int!
  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 EnnoblementFilterOr {
  newOwnerID: [Int!]
  newOwnerTribeID: [Int!]
  oldOwnerID: [Int!]
  oldOwnerTribeID: [Int!]
}

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

  newOwnerID: [Int!]
  newOwnerIDNEQ: [Int!]
  newOwnerFilter: PlayerFilter
  newOwnerTribeID: [Int!]
  newOwnerTribeIDNEQ: [Int!]
  newOwnerTribeFilter: TribeFilter

  oldOwnerID: [Int!]
  oldOwnerIDNEQ: [Int!]
  oldOwnerFilter: PlayerFilter
  oldOwnerTribeID: [Int!]
  oldOwnerTribeIDNEQ: [Int!]
  oldOwnerTribeFilter: TribeFilter

  ennobledAt: Time
  ennobledAtGT: Time
  ennobledAtGTE: Time
  ennobledAtLT: Time
  ennobledAtLTE: Time

  or: EnnoblementFilterOr
}

extend type Query {
  ennoblements(
    server: String!
    filter: EnnoblementFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): EnnoblementList!
}
`, BuiltIn: false},
	{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!
  lastActivityAt: 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

  lastActivityAt: Time
  lastActivityAtGT: Time
  lastActivityAtGTE: Time
  lastActivityAtLT: Time
  lastActivityAtLTE: Time

  deletedAt: Time
  deletedAtGT: Time
  deletedAtGTE: Time
  deletedAtLT: Time
  deletedAtLTE: Time

  tribeID: [Int!]
  tribeIDNEQ: [Int!]
  tribeFilter: TribeFilter
}

type FoundPlayer {
  server: String!
  id: Int!
  name: String!
  bestRank: Int!
  mostPoints: Int!
  mostVillages: Int!
  tribeID: Int!
  tribeTag: String!
}

type FoundPlayerList {
  items: [FoundPlayer!]
  total: Int!
}

extend type Query {
  players(
    server: String!
    filter: PlayerFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): PlayerList!
  player(server: String!, id: Int!): Player
  searchPlayer(
    version: String!
    name: String
    id: Int
    limit: Int
    offset: Int
    sort: [String!]
  ): FoundPlayerList!
}
`, BuiltIn: false},
	{Name: "schema/player_history.graphql", Input: `type PlayerHistoryRecord {
  id: Int!
  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!]
  playerFilter: PlayerFilter

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

extend type Query {
  playerHistory(
    server: String!
    filter: PlayerHistoryFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): PlayerHistory!
}
`, BuiltIn: false},
	{Name: "schema/scalars.graphql", Input: `scalar Time
`, BuiltIn: false},
	{Name: "schema/server.graphql", Input: `enum ServerStatus {
  OPEN
  open
  CLOSED
  closed
}

type Server {
  key: String!
  status: ServerStatus!
  numberOfPlayers: Int!
  numberOfTribes: Int!
  numberOfVillages: Int!

  version: Version @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!]

  versionCode: [VersionCode!]
  versionCodeNEQ: [VersionCode!]
}

extend type Query {
  servers(
    filter: ServerFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): ServerList!
  server(key: String!): Server
}
`, BuiltIn: false},
	{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: Float!
  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},
	{Name: "schema/server_stats.graphql", Input: `type ServerStatsRecord {
  id: Int!
  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
}

extend type Query {
  serverStats(
    server: String!
    filter: ServerStatsFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): ServerStats!
}
`, BuiltIn: false},
	{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 TribeFilterOr {
  id: [Int!]
  tag: [String!]
  tagIEQ: String
  name: [String!]
  nameIEQ: String
}

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

  or: TribeFilterOr
}

type FoundTribe {
  server: String!
  id: Int!
  tag: String!
  name: String!
  bestRank: Int!
  mostPoints: Int!
  mostVillages: Int!
}

type FoundTribeList {
  items: [FoundTribe!]
  total: Int!
}

extend type Query {
  tribes(
    server: String!
    filter: TribeFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): TribeList!
  tribe(server: String!, id: Int!): Tribe
  searchTribe(
    version: String!
    query: String!
    limit: Int
    offset: Int
    sort: [String!]
  ): FoundTribeList!
}
`, BuiltIn: false},
	{Name: "schema/tribe_change.graphql", Input: `type TribeChangeRecord {
  id: Int!
  player: Player @goField(forceResolver: true)
  oldTribe: Tribe @goField(forceResolver: true)
  newTribe: Tribe @goField(forceResolver: true)
  createdAt: Time!
}

type TribeChanges {
  total: Int!
  items: [TribeChangeRecord!]
}

input TribeChangeFilterOr {
  oldTribeID: [Int!]
  newTribeID: [Int!]
}

input TribeChangeFilter {
  playerID: [Int!]
  playerIDNEQ: [Int!]
  playerFilter: PlayerFilter

  oldTribeID: [Int!]
  oldTribeIDNEQ: [Int!]
  oldTribeFilter: TribeFilter

  newTribeID: [Int!]
  newTribeIDNEQ: [Int!]
  newTribeFilter: TribeFilter

  createdAt: Time
  createdAtGT: Time
  createdAtGTE: Time
  createdAtLT: Time
  createdAtLTE: Time

  or: TribeChangeFilterOr
}

extend type Query {
  tribeChanges(
    server: String!
    filter: TribeChangeFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): TribeChanges!
}
`, BuiltIn: false},
	{Name: "schema/tribe_history.graphql", Input: `type TribeHistoryRecord {
  id: Int!
  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!]
  tribeFilter: TribeFilter

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

extend type Query {
  tribeHistory(
    server: String!
    filter: TribeHistoryFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): TribeHistory!
}
`, BuiltIn: false},
	{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},
	{Name: "schema/version.graphql", Input: `enum VersionCode {
  PL
  pl
  EN
  en
  DE
  de
  UK
  uk
  IT
  it
  FR
  fr
  US
  us
  NL
  nl
  ES
  es
  RO
  ro
  RU
  ru
  GR
  gr
  TR
  tr
  CS
  cs
  CH
  ch
  PT
  pt
  BR
  br
  HU
  hu
  SK
  sk
}

type Version {
  code: VersionCode!
  name: String!
  host: String!
  timezone: String!
}

input VersionFilter {
  code: [VersionCode!]
  codeNEQ: [VersionCode!]

  host: [String!]
  hostNEQ: [String!]
  hostMATCH: String
  hostIEQ: String
}

type VersionList {
  items: [Version!]
  total: Int!
}

extend type Query {
  versions(
    filter: VersionFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): VersionList!
  version(code: VersionCode!): Version
}
`, BuiltIn: false},
	{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
  xy: [String!]

  bonus: Int
  bonusGT: Int
  bonusGTE: Int
  bonusLT: Int
  bonusLTE: Int

  playerID: [Int!]
  playerIDNEQ: [Int!]
  playerFilter: PlayerFilter
}

extend type Query {
  villages(
    server: String!
    filter: VillageFilter
    limit: Int
    offset: Int
    sort: [String!]
  ): 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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
		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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.DailyPlayerStatsFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalODailyPlayerStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyPlayerStatsFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.DailyTribeStatsFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalODailyTribeStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyTribeStatsFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.EnnoblementFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalOEnnoblementFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐEnnoblementFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.PlayerHistoryFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalOPlayerHistoryFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerHistoryFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.PlayerFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	return args, nil
}

func (ec *executionContext) field_Query_searchPlayer_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["version"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("version"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["version"] = arg0
	var arg1 *string
	if tmp, ok := rawArgs["name"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["name"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg3
	var arg4 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg4, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg4
	var arg5 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg5, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg5
	return args, nil
}

func (ec *executionContext) field_Query_searchTribe_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["version"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("version"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["version"] = arg0
	var arg1 string
	if tmp, ok := rawArgs["query"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))
		arg1, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["query"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.ServerStatsFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalOServerStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatsFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("key"))
		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 *twmodel.ServerFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg0, err = ec.unmarshalOServerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg2
	var arg3 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.TribeChangeFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalOTribeChangeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeChangeFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.TribeHistoryFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalOTribeHistoryFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeHistoryFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.TribeFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	return args, nil
}

func (ec *executionContext) field_Query_version_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 twmodel.VersionCode
	if tmp, ok := rawArgs["code"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code"))
		arg0, err = ec.unmarshalNVersionCode2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCode(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["code"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_versions_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *twmodel.VersionFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg0, err = ec.unmarshalOVersionFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg2
	var arg3 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 int
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("server"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["server"] = arg0
	var arg1 *twmodel.VillageFilter
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg1, err = ec.unmarshalOVillageFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVillageFilter(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg1
	var arg2 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg2
	var arg3 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg3
	var arg4 []string
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg4, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg4
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
		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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
		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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_barracks(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_stable(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_garage(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_watchtower(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_snob(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_smith(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_place(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_statue(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_market(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_wood(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_stone(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_iron(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_farm(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_storage(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_hide(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx, field.Selections, res)
}

func (ec *executionContext) _BuildingConfig_wall(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Building)
	fc.Result = res
	return ec.marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.DailyPlayerStats)
	fc.Result = res
	return ec.marshalODailyPlayerStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyPlayerStatsᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _DailyPlayerStatsRecord_player(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyPlayerStatsRecord_villages(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.DailyTribeStats)
	fc.Result = res
	return ec.marshalODailyTribeStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyTribeStatsᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _DailyTribeStatsRecord_tribe(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _DailyTribeStatsRecord_members(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _Ennoblement_village(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Village)
	fc.Result = res
	return ec.marshalOVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVillage(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_newOwner(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_newOwnerTribe(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_oldOwner(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_oldOwnerTribe(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _Ennoblement_ennobledAt(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.Ennoblement)
	fc.Result = res
	return ec.marshalOEnnoblement2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundPlayer_server(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundPlayer) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayer",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Server, nil
	})
	if err != nil {
		ec.Error(ctx, 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) _FoundPlayer_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundPlayer) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayer",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundPlayer_name(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundPlayer) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayer",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundPlayer_bestRank(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundPlayer) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayer",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundPlayer_mostPoints(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundPlayer) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayer",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundPlayer_mostVillages(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundPlayer) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayer",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundPlayer_tribeID(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundPlayer) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayer",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TribeID, nil
	})
	if err != nil {
		ec.Error(ctx, 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) _FoundPlayer_tribeTag(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundPlayer) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayer",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TribeTag, nil
	})
	if err != nil {
		ec.Error(ctx, 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) _FoundPlayerList_items(ctx context.Context, field graphql.CollectedField, obj *FoundPlayerList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayerList",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.FoundPlayer)
	fc.Result = res
	return ec.marshalOFoundPlayer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐFoundPlayerᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _FoundPlayerList_total(ctx context.Context, field graphql.CollectedField, obj *FoundPlayerList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundPlayerList",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundTribe_server(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundTribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundTribe",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Server, nil
	})
	if err != nil {
		ec.Error(ctx, 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) _FoundTribe_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundTribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundTribe",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundTribe_tag(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundTribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundTribe",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundTribe_name(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundTribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundTribe",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundTribe_bestRank(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundTribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundTribe",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundTribe_mostPoints(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundTribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundTribe",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundTribe_mostVillages(ctx context.Context, field graphql.CollectedField, obj *twmodel.FoundTribe) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundTribe",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _FoundTribeList_items(ctx context.Context, field graphql.CollectedField, obj *FoundTribeList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundTribeList",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.FoundTribe)
	fc.Result = res
	return ec.marshalOFoundTribe2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐFoundTribeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _FoundTribeList_total(ctx context.Context, field graphql.CollectedField, obj *FoundTribeList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "FoundTribeList",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _Player_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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_lastActivityAt(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastActivityAt, nil
	})
	if err != nil {
		ec.Error(ctx, 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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: 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.(*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _Player_servers(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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 *twmodel.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,
		IsResolver: 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.([]*twmodel.PlayerNameChange)
	fc.Result = res
	return ec.marshalNPlayerNameChange2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.PlayerHistory)
	fc.Result = res
	return ec.marshalOPlayerHistoryRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerHistoryᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _PlayerHistoryRecord_player(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_totalVillages(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: 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.(*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _PlayerHistoryRecord_createDate(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: 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"].(*twmodel.DailyPlayerStatsFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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,
		IsResolver: 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"].(*twmodel.DailyTribeStatsFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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,
		IsResolver: 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"].(*twmodel.EnnoblementFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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_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,
		IsResolver: 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"].(*twmodel.PlayerFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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,
		IsResolver: 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.(*twmodel.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_searchPlayer(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,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_searchPlayer_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().SearchPlayer(rctx, args["version"].(string), args["name"].(*string), args["id"].(*int), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*FoundPlayerList)
	fc.Result = res
	return ec.marshalNFoundPlayerList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐFoundPlayerList(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,
		IsResolver: 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"].(*twmodel.PlayerHistoryFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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,
		IsResolver: 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"].(*twmodel.ServerFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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,
		IsResolver: 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.(*twmodel.Server)
	fc.Result = res
	return ec.marshalOServer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: 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"].(*twmodel.ServerStatsFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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,
		IsResolver: 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"].(*twmodel.TribeFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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,
		IsResolver: 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.(*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_searchTribe(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,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_searchTribe_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().SearchTribe(rctx, args["version"].(string), args["query"].(string), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*FoundTribeList)
	fc.Result = res
	return ec.marshalNFoundTribeList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐFoundTribeList(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,
		IsResolver: 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"].(*twmodel.TribeChangeFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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,
		IsResolver: 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"].(*twmodel.TribeHistoryFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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_versions(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,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_versions_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().Versions(rctx, args["filter"].(*twmodel.VersionFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*VersionList)
	fc.Result = res
	return ec.marshalNVersionList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐVersionList(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_version(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,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_version_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().Version(rctx, args["code"].(twmodel.VersionCode))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*twmodel.Version)
	fc.Result = res
	return ec.marshalOVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersion(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,
		IsResolver: 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"].(*twmodel.VillageFilter), args["limit"].(*int), args["offset"].(*int), args["sort"].([]string))
	})
	if err != nil {
		ec.Error(ctx, 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,
		IsResolver: 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.(*twmodel.Village)
	fc.Result = res
	return ec.marshalOVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	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,
		IsResolver: false,
	}

	ctx = graphql.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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerStatus)
	fc.Result = res
	return ec.marshalNServerStatus2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatus(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_numberOfPlayers(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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_version(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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().Version(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*twmodel.Version)
	fc.Result = res
	return ec.marshalOVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersion(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_config(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfig)
	fc.Result = res
	return ec.marshalNServerConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfig(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_unitConfig(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.UnitConfig)
	fc.Result = res
	return ec.marshalNUnitConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnitConfig(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_buildingConfig(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.BuildingConfig)
	fc.Result = res
	return ec.marshalNBuildingConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuildingConfig(ctx, field.Selections, res)
}

func (ec *executionContext) _Server_dataUpdatedAt(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigBuild)
	fc.Result = res
	return ec.marshalNServerConfigBuild2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigBuild(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_misc(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigMisc)
	fc.Result = res
	return ec.marshalNServerConfigMisc2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigMisc(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_commands(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigCommands)
	fc.Result = res
	return ec.marshalNServerConfigCommands2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigCommands(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_newbie(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigNewbie)
	fc.Result = res
	return ec.marshalNServerConfigNewbie2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigNewbie(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_game(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigGame)
	fc.Result = res
	return ec.marshalNServerConfigGame2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigGame(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_buildings(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigBuildings)
	fc.Result = res
	return ec.marshalNServerConfigBuildings2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigBuildings(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_snob(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigSnob)
	fc.Result = res
	return ec.marshalNServerConfigSnob2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigSnob(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_ally(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigAlly)
	fc.Result = res
	return ec.marshalNServerConfigAlly2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigAlly(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_coord(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigCoord)
	fc.Result = res
	return ec.marshalNServerConfigCoord2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigCoord(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_sitter(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigSitter)
	fc.Result = res
	return ec.marshalNServerConfigSitter2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigSitter(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_sleep(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigSleep)
	fc.Result = res
	return ec.marshalNServerConfigSleep2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigSleep(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_night(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigNight)
	fc.Result = res
	return ec.marshalNServerConfigNight2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigNight(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfig_win(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.ServerConfigWin)
	fc.Result = res
	return ec.marshalNServerConfigWin2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigWin(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigAlly_noHarm(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerConfigGame_barbarianRise(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.Server)
	fc.Result = res
	return ec.marshalOServer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.ServerStats)
	fc.Result = res
	return ec.marshalOServerStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _ServerStatsRecord_activePlayers(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _TribeChangeRecord_player(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayer(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeChangeRecord_oldTribe(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeChangeRecord_newTribe(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeChangeRecord_createdAt(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.TribeChange)
	fc.Result = res
	return ec.marshalOTribeChangeRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.TribeHistory)
	fc.Result = res
	return ec.marshalOTribeHistoryRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeHistoryᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _TribeHistoryRecord_tribe(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: 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.(*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx, field.Selections, res)
}

func (ec *executionContext) _TribeHistoryRecord_totalVillages(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.Tribe)
	fc.Result = res
	return ec.marshalOTribe2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_sword(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_axe(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_archer(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_spy(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_light(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_marcher(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_heavy(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_ram(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_catapult(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_knight(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_snob(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _UnitConfig_militia(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.(twmodel.Unit)
	fc.Result = res
	return ec.marshalNUnit2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnit(ctx, field.Selections, res)
}

func (ec *executionContext) _Version_code(ctx context.Context, field graphql.CollectedField, obj *twmodel.Version) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Version",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Code, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(twmodel.VersionCode)
	fc.Result = res
	return ec.marshalNVersionCode2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCode(ctx, field.Selections, res)
}

func (ec *executionContext) _Version_name(ctx context.Context, field graphql.CollectedField, obj *twmodel.Version) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Version",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _Version_host(ctx context.Context, field graphql.CollectedField, obj *twmodel.Version) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Version",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _Version_timezone(ctx context.Context, field graphql.CollectedField, obj *twmodel.Version) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Version",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _VersionList_items(ctx context.Context, field graphql.CollectedField, obj *VersionList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "VersionList",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.Version)
	fc.Result = res
	return ec.marshalOVersion2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _VersionList_total(ctx context.Context, field graphql.CollectedField, obj *VersionList) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "VersionList",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) _Village_id(ctx context.Context, field graphql.CollectedField, obj *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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 *twmodel.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,
		IsResolver: 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.(*twmodel.Player)
	fc.Result = res
	return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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.([]*twmodel.Village)
	fc.Result = res
	return ec.marshalOVillage2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐ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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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) ___Directive_isRepeatable(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsRepeatable, nil
	})
	if err != nil {
		ec.Error(ctx, 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_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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(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{}) (twmodel.DailyPlayerStatsFilter, error) {
	var it twmodel.DailyPlayerStatsFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "playerID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerID"))
			it.PlayerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerIDNEQ"))
			it.PlayerIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerFilter"))
			it.PlayerFilter, err = ec.unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDate":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDate"))
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGT"))
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGTE"))
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLT"))
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLTE"))
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputDailyTribeStatsFilter(ctx context.Context, obj interface{}) (twmodel.DailyTribeStatsFilter, error) {
	var it twmodel.DailyTribeStatsFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "tribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tribeID"))
			it.TribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tribeIDNEQ"))
			it.TribeIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tribeFilter"))
			it.TribeFilter, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDate":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDate"))
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGT"))
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGTE"))
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLT"))
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLTE"))
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputEnnoblementFilter(ctx context.Context, obj interface{}) (twmodel.EnnoblementFilter, error) {
	var it twmodel.EnnoblementFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "villageID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("villageID"))
			it.VillageID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "villageIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("villageIDNEQ"))
			it.VillageIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "villageFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("villageFilter"))
			it.VillageFilter, err = ec.unmarshalOVillageFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVillageFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newOwnerID"))
			it.NewOwnerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newOwnerIDNEQ"))
			it.NewOwnerIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newOwnerFilter"))
			it.NewOwnerFilter, err = ec.unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerTribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newOwnerTribeID"))
			it.NewOwnerTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerTribeIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newOwnerTribeIDNEQ"))
			it.NewOwnerTribeIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerTribeFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newOwnerTribeFilter"))
			it.NewOwnerTribeFilter, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldOwnerID"))
			it.OldOwnerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldOwnerIDNEQ"))
			it.OldOwnerIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldOwnerFilter"))
			it.OldOwnerFilter, err = ec.unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerTribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldOwnerTribeID"))
			it.OldOwnerTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerTribeIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldOwnerTribeIDNEQ"))
			it.OldOwnerTribeIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerTribeFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldOwnerTribeFilter"))
			it.OldOwnerTribeFilter, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ennobledAt"))
			it.EnnobledAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAtGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ennobledAtGT"))
			it.EnnobledAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAtGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ennobledAtGTE"))
			it.EnnobledAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAtLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ennobledAtLT"))
			it.EnnobledAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "ennobledAtLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ennobledAtLTE"))
			it.EnnobledAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "or":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or"))
			it.Or, err = ec.unmarshalOEnnoblementFilterOr2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐEnnoblementFilterOr(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputEnnoblementFilterOr(ctx context.Context, obj interface{}) (twmodel.EnnoblementFilterOr, error) {
	var it twmodel.EnnoblementFilterOr
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "newOwnerID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newOwnerID"))
			it.NewOwnerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newOwnerTribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newOwnerTribeID"))
			it.NewOwnerTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldOwnerID"))
			it.OldOwnerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldOwnerTribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldOwnerTribeID"))
			it.OldOwnerTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPlayerFilter(ctx context.Context, obj interface{}) (twmodel.PlayerFilter, error) {
	var it twmodel.PlayerFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ"))
			it.IDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "exists":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("exists"))
			it.Exists, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			it.Name, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ"))
			it.NameNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMATCH":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMATCH"))
			it.NameMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameIEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIEQ"))
			it.NameIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillages":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillages"))
			it.TotalVillages, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillagesGT"))
			it.TotalVillagesGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillagesGTE"))
			it.TotalVillagesGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillagesLT"))
			it.TotalVillagesLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillagesLTE"))
			it.TotalVillagesLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "points":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("points"))
			it.Points, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsGT"))
			it.PointsGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsGTE"))
			it.PointsGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsLT"))
			it.PointsLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsLTE"))
			it.PointsLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rank":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rank"))
			it.Rank, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankGT"))
			it.RankGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankGTE"))
			it.RankGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankLT"))
			it.RankLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankLTE"))
			it.RankLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAtt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAtt"))
			it.RankAtt, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAttGT"))
			it.RankAttGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAttGTE"))
			it.RankAttGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAttLT"))
			it.RankAttLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAttLTE"))
			it.RankAttLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAtt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAtt"))
			it.ScoreAtt, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAttGT"))
			it.ScoreAttGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAttGTE"))
			it.ScoreAttGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAttLT"))
			it.ScoreAttLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAttLTE"))
			it.ScoreAttLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDef":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDef"))
			it.RankDef, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDefGT"))
			it.RankDefGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDefGTE"))
			it.RankDefGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDefLT"))
			it.RankDefLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDefLTE"))
			it.RankDefLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDef":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDef"))
			it.ScoreDef, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDefGT"))
			it.ScoreDefGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDefGTE"))
			it.ScoreDefGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDefLT"))
			it.ScoreDefLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDefLTE"))
			it.ScoreDefLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSup":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankSup"))
			it.RankSup, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSupGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankSupGT"))
			it.RankSupGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSupGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankSupGTE"))
			it.RankSupGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSupLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankSupLT"))
			it.RankSupLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankSupLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankSupLTE"))
			it.RankSupLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSup":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreSup"))
			it.ScoreSup, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSupGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreSupGT"))
			it.ScoreSupGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSupGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreSupGTE"))
			it.ScoreSupGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSupLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreSupLT"))
			it.ScoreSupLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreSupLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreSupLTE"))
			it.ScoreSupLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotal":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotal"))
			it.RankTotal, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotalGT"))
			it.RankTotalGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotalGTE"))
			it.RankTotalGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotalLT"))
			it.RankTotalLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotalLTE"))
			it.RankTotalLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotal":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotal"))
			it.ScoreTotal, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotalGT"))
			it.ScoreTotalGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotalGTE"))
			it.ScoreTotalGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotalLT"))
			it.ScoreTotalLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotalLTE"))
			it.ScoreTotalLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowth":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dailyGrowth"))
			it.DailyGrowth, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowthGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dailyGrowthGT"))
			it.DailyGrowthGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowthGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dailyGrowthGTE"))
			it.DailyGrowthGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowthLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dailyGrowthLT"))
			it.DailyGrowthLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dailyGrowthLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dailyGrowthLTE"))
			it.DailyGrowthLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinedAt"))
			it.JoinedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAtGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinedAtGT"))
			it.JoinedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAtGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinedAtGTE"))
			it.JoinedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAtLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinedAtLT"))
			it.JoinedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "joinedAtLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinedAtLTE"))
			it.JoinedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastActivityAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastActivityAt"))
			it.LastActivityAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastActivityAtGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastActivityAtGT"))
			it.LastActivityAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastActivityAtGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastActivityAtGTE"))
			it.LastActivityAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastActivityAtLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastActivityAtLT"))
			it.LastActivityAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastActivityAtLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastActivityAtLTE"))
			it.LastActivityAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAt"))
			it.DeletedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGT"))
			it.DeletedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGTE"))
			it.DeletedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLT"))
			it.DeletedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLTE"))
			it.DeletedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tribeID"))
			it.TribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tribeIDNEQ"))
			it.TribeIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tribeFilter"))
			it.TribeFilter, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilter(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPlayerHistoryFilter(ctx context.Context, obj interface{}) (twmodel.PlayerHistoryFilter, error) {
	var it twmodel.PlayerHistoryFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "playerID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerID"))
			it.PlayerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerIDNEQ"))
			it.PlayerIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerFilter"))
			it.PlayerFilter, err = ec.unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDate":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDate"))
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGT"))
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGTE"))
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLT"))
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLTE"))
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputServerFilter(ctx context.Context, obj interface{}) (twmodel.ServerFilter, error) {
	var it twmodel.ServerFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "key":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("key"))
			it.Key, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "keyNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("keyNEQ"))
			it.KeyNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "keyMATCH":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("keyMATCH"))
			it.KeyMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "keyIEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("keyIEQ"))
			it.KeyIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "status":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("status"))
			it.Status, err = ec.unmarshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatusᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "statusNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNEQ"))
			it.StatusNEQ, err = ec.unmarshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatusᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "versionCode":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionCode"))
			it.VersionCode, err = ec.unmarshalOVersionCode2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCodeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "versionCodeNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionCodeNEQ"))
			it.VersionCodeNEQ, err = ec.unmarshalOVersionCode2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCodeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputServerStatsFilter(ctx context.Context, obj interface{}) (twmodel.ServerStatsFilter, error) {
	var it twmodel.ServerStatsFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "createDate":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDate"))
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGT"))
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGTE"))
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLT"))
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLTE"))
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTribeChangeFilter(ctx context.Context, obj interface{}) (twmodel.TribeChangeFilter, error) {
	var it twmodel.TribeChangeFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "playerID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerID"))
			it.PlayerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerIDNEQ"))
			it.PlayerIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerFilter"))
			it.PlayerFilter, err = ec.unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldTribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldTribeID"))
			it.OldTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldTribeIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldTribeIDNEQ"))
			it.OldTribeIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "oldTribeFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldTribeFilter"))
			it.OldTribeFilter, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "newTribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newTribeID"))
			it.NewTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newTribeIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newTribeIDNEQ"))
			it.NewTribeIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newTribeFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newTribeFilter"))
			it.NewTribeFilter, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGT"))
			it.CreatedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGTE"))
			it.CreatedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLT"))
			it.CreatedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLTE"))
			it.CreatedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "or":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or"))
			it.Or, err = ec.unmarshalOTribeChangeFilterOr2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeChangeFilterOr(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTribeChangeFilterOr(ctx context.Context, obj interface{}) (twmodel.TribeChangeFilterOr, error) {
	var it twmodel.TribeChangeFilterOr
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "oldTribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("oldTribeID"))
			it.OldTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "newTribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("newTribeID"))
			it.NewTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTribeFilter(ctx context.Context, obj interface{}) (twmodel.TribeFilter, error) {
	var it twmodel.TribeFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ"))
			it.IDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "exists":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("exists"))
			it.Exists, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "tag":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tag"))
			it.Tag, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tagNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tagNEQ"))
			it.TagNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tagMATCH":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tagMATCH"))
			it.TagMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "tagIEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tagIEQ"))
			it.TagIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			it.Name, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ"))
			it.NameNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMATCH":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMATCH"))
			it.NameMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameIEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIEQ"))
			it.NameIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembers":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalMembers"))
			it.TotalMembers, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembersGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalMembersGT"))
			it.TotalMembersGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembersGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalMembersGTE"))
			it.TotalMembersGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembersLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalMembersLT"))
			it.TotalMembersLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalMembersLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalMembersLTE"))
			it.TotalMembersLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillages":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillages"))
			it.TotalVillages, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillagesGT"))
			it.TotalVillagesGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillagesGTE"))
			it.TotalVillagesGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillagesLT"))
			it.TotalVillagesLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "totalVillagesLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("totalVillagesLTE"))
			it.TotalVillagesLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "points":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("points"))
			it.Points, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsGT"))
			it.PointsGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsGTE"))
			it.PointsGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsLT"))
			it.PointsLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsLTE"))
			it.PointsLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPoints":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("allPoints"))
			it.AllPoints, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPointsGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("allPointsGT"))
			it.AllPointsGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPointsGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("allPointsGTE"))
			it.AllPointsGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPointsLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("allPointsLT"))
			it.AllPointsLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "allPointsLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("allPointsLTE"))
			it.AllPointsLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rank":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rank"))
			it.Rank, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankGT"))
			it.RankGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankGTE"))
			it.RankGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankLT"))
			it.RankLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankLTE"))
			it.RankLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAtt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAtt"))
			it.RankAtt, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAttGT"))
			it.RankAttGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAttGTE"))
			it.RankAttGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAttLT"))
			it.RankAttLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankAttLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankAttLTE"))
			it.RankAttLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAtt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAtt"))
			it.ScoreAtt, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAttGT"))
			it.ScoreAttGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAttGTE"))
			it.ScoreAttGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAttLT"))
			it.ScoreAttLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreAttLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreAttLTE"))
			it.ScoreAttLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDef":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDef"))
			it.RankDef, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDefGT"))
			it.RankDefGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDefGTE"))
			it.RankDefGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDefLT"))
			it.RankDefLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankDefLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankDefLTE"))
			it.RankDefLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDef":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDef"))
			it.ScoreDef, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDefGT"))
			it.ScoreDefGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDefGTE"))
			it.ScoreDefGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDefLT"))
			it.ScoreDefLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreDefLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreDefLTE"))
			it.ScoreDefLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotal":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotal"))
			it.RankTotal, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotalGT"))
			it.RankTotalGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotalGTE"))
			it.RankTotalGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotalLT"))
			it.RankTotalLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "rankTotalLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rankTotalLTE"))
			it.RankTotalLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotal":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotal"))
			it.ScoreTotal, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotalGT"))
			it.ScoreTotalGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotalGTE"))
			it.ScoreTotalGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotalLT"))
			it.ScoreTotalLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "scoreTotalLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scoreTotalLTE"))
			it.ScoreTotalLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominance":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dominance"))
			it.Dominance, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominanceGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dominanceGT"))
			it.DominanceGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominanceGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dominanceGTE"))
			it.DominanceGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominanceLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dominanceLT"))
			it.DominanceLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "dominanceLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dominanceLTE"))
			it.DominanceLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGT"))
			it.CreatedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGTE"))
			it.CreatedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLT"))
			it.CreatedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLTE"))
			it.CreatedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAt"))
			it.DeletedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGT"))
			it.DeletedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGTE"))
			it.DeletedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLT"))
			it.DeletedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "deletedAtLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLTE"))
			it.DeletedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "or":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or"))
			it.Or, err = ec.unmarshalOTribeFilterOr2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilterOr(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTribeFilterOr(ctx context.Context, obj interface{}) (twmodel.TribeFilterOr, error) {
	var it twmodel.TribeFilterOr
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tag":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tag"))
			it.Tag, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tagIEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tagIEQ"))
			it.TagIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			it.Name, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameIEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIEQ"))
			it.NameIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTribeHistoryFilter(ctx context.Context, obj interface{}) (twmodel.TribeHistoryFilter, error) {
	var it twmodel.TribeHistoryFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "tribeID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tribeID"))
			it.TribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tribeIDNEQ"))
			it.TribeIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "tribeFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tribeFilter"))
			it.TribeFilter, err = ec.unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilter(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDate":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDate"))
			it.CreateDate, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGT"))
			it.CreateDateGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateGTE"))
			it.CreateDateGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLT"))
			it.CreateDateLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createDateLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createDateLTE"))
			it.CreateDateLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputVersionFilter(ctx context.Context, obj interface{}) (twmodel.VersionFilter, error) {
	var it twmodel.VersionFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "code":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code"))
			it.Code, err = ec.unmarshalOVersionCode2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCodeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeNEQ"))
			it.CodeNEQ, err = ec.unmarshalOVersionCode2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCodeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "host":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("host"))
			it.Host, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "hostNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hostNEQ"))
			it.HostNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "hostMATCH":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hostMATCH"))
			it.HostMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "hostIEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hostIEQ"))
			it.HostIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputVillageFilter(ctx context.Context, obj interface{}) (twmodel.VillageFilter, error) {
	var it twmodel.VillageFilter
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	for k, v := range asMap {
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ"))
			it.IDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			it.Name, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ"))
			it.NameNEQ, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMATCH":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMATCH"))
			it.NameMATCH, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameIEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIEQ"))
			it.NameIEQ, err = ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "points":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("points"))
			it.Points, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsGT"))
			it.PointsGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsGTE"))
			it.PointsGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsLT"))
			it.PointsLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "pointsLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pointsLTE"))
			it.PointsLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "xGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("xGT"))
			it.XGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "xGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("xGTE"))
			it.XGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "xLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("xLT"))
			it.XLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "xLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("xLTE"))
			it.XLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "yGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("yGT"))
			it.YGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "yGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("yGTE"))
			it.YGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "yLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("yLT"))
			it.YLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "yLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("yLTE"))
			it.YLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "xy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("xy"))
			it.XY, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonus":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("bonus"))
			it.Bonus, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonusGT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("bonusGT"))
			it.BonusGT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonusGTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("bonusGTE"))
			it.BonusGTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonusLT":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("bonusLT"))
			it.BonusLT, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "bonusLTE":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("bonusLTE"))
			it.BonusLTE, err = ec.unmarshalOInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerID":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerID"))
			it.PlayerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerIDNEQ":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerIDNEQ"))
			it.PlayerIDNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "playerFilter":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("playerFilter"))
			it.PlayerFilter, err = ec.unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerFilter(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 *twmodel.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 *twmodel.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 *twmodel.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 "id":
			out.Values[i] = ec._DailyPlayerStatsRecord_id(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._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 *twmodel.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 "id":
			out.Values[i] = ec._DailyTribeStatsRecord_id(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._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 *twmodel.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 "id":
			out.Values[i] = ec._Ennoblement_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		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 foundPlayerImplementors = []string{"FoundPlayer"}

func (ec *executionContext) _FoundPlayer(ctx context.Context, sel ast.SelectionSet, obj *twmodel.FoundPlayer) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, foundPlayerImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("FoundPlayer")
		case "server":
			out.Values[i] = ec._FoundPlayer_server(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "id":
			out.Values[i] = ec._FoundPlayer_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._FoundPlayer_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "bestRank":
			out.Values[i] = ec._FoundPlayer_bestRank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mostPoints":
			out.Values[i] = ec._FoundPlayer_mostPoints(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mostVillages":
			out.Values[i] = ec._FoundPlayer_mostVillages(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "tribeID":
			out.Values[i] = ec._FoundPlayer_tribeID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "tribeTag":
			out.Values[i] = ec._FoundPlayer_tribeTag(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 foundPlayerListImplementors = []string{"FoundPlayerList"}

func (ec *executionContext) _FoundPlayerList(ctx context.Context, sel ast.SelectionSet, obj *FoundPlayerList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, foundPlayerListImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("FoundPlayerList")
		case "items":
			out.Values[i] = ec._FoundPlayerList_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._FoundPlayerList_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 foundTribeImplementors = []string{"FoundTribe"}

func (ec *executionContext) _FoundTribe(ctx context.Context, sel ast.SelectionSet, obj *twmodel.FoundTribe) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, foundTribeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("FoundTribe")
		case "server":
			out.Values[i] = ec._FoundTribe_server(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "id":
			out.Values[i] = ec._FoundTribe_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "tag":
			out.Values[i] = ec._FoundTribe_tag(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._FoundTribe_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "bestRank":
			out.Values[i] = ec._FoundTribe_bestRank(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mostPoints":
			out.Values[i] = ec._FoundTribe_mostPoints(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mostVillages":
			out.Values[i] = ec._FoundTribe_mostVillages(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 foundTribeListImplementors = []string{"FoundTribeList"}

func (ec *executionContext) _FoundTribeList(ctx context.Context, sel ast.SelectionSet, obj *FoundTribeList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, foundTribeListImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("FoundTribeList")
		case "items":
			out.Values[i] = ec._FoundTribeList_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._FoundTribeList_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 playerImplementors = []string{"Player"}

func (ec *executionContext) _Player(ctx context.Context, sel ast.SelectionSet, obj *twmodel.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 "lastActivityAt":
			out.Values[i] = ec._Player_lastActivityAt(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 *twmodel.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 "id":
			out.Values[i] = ec._PlayerHistoryRecord_id(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._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 *twmodel.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 "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 "searchPlayer":
			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_searchPlayer(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				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 "searchTribe":
			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_searchTribe(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				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 "versions":
			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_versions(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "version":
			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_version(ctx, field)
				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 *twmodel.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 "version":
			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_version(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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 *twmodel.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 "id":
			out.Values[i] = ec._ServerStatsRecord_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		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 *twmodel.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 *twmodel.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 "id":
			out.Values[i] = ec._TribeChangeRecord_id(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._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 *twmodel.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 "id":
			out.Values[i] = ec._TribeHistoryRecord_id(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._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 *twmodel.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 *twmodel.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 versionImplementors = []string{"Version"}

func (ec *executionContext) _Version(ctx context.Context, sel ast.SelectionSet, obj *twmodel.Version) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, versionImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Version")
		case "code":
			out.Values[i] = ec._Version_code(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._Version_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "host":
			out.Values[i] = ec._Version_host(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "timezone":
			out.Values[i] = ec._Version_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 versionListImplementors = []string{"VersionList"}

func (ec *executionContext) _VersionList(ctx context.Context, sel ast.SelectionSet, obj *VersionList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, versionListImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("VersionList")
		case "items":
			out.Values[i] = ec._VersionList_items(ctx, field, obj)
		case "total":
			out.Values[i] = ec._VersionList_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 villageImplementors = []string{"Village"}

func (ec *executionContext) _Village(ctx context.Context, sel ast.SelectionSet, obj *twmodel.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++
			}
		case "isRepeatable":
			out.Values[i] = ec.___Directive_isRepeatable(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) {
	res, err := graphql.UnmarshalBoolean(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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) {
	res, err := graphql.UnmarshalBoolean(v)
	return &res, graphql.ErrorOnPath(ctx, 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
	}
	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) marshalNBuilding2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuilding(ctx context.Context, sel ast.SelectionSet, v twmodel.Building) graphql.Marshaler {
	return ec._Building(ctx, sel, &v)
}

func (ec *executionContext) marshalNBuildingConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐBuildingConfig(ctx context.Context, sel ast.SelectionSet, v twmodel.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) marshalNDailyPlayerStatsRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyPlayerStats(ctx context.Context, sel ast.SelectionSet, v *twmodel.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) marshalNDailyTribeStatsRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyTribeStats(ctx context.Context, sel ast.SelectionSet, v *twmodel.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) marshalNEnnoblement2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐEnnoblement(ctx context.Context, sel ast.SelectionSet, v *twmodel.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) {
	res, err := graphql.UnmarshalFloat(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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) marshalNFoundPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐFoundPlayer(ctx context.Context, sel ast.SelectionSet, v *twmodel.FoundPlayer) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._FoundPlayer(ctx, sel, v)
}

func (ec *executionContext) marshalNFoundPlayerList2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐFoundPlayerList(ctx context.Context, sel ast.SelectionSet, v FoundPlayerList) graphql.Marshaler {
	return ec._FoundPlayerList(ctx, sel, &v)
}

func (ec *executionContext) marshalNFoundPlayerList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐFoundPlayerList(ctx context.Context, sel ast.SelectionSet, v *FoundPlayerList) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._FoundPlayerList(ctx, sel, v)
}

func (ec *executionContext) marshalNFoundTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐFoundTribe(ctx context.Context, sel ast.SelectionSet, v *twmodel.FoundTribe) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._FoundTribe(ctx, sel, v)
}

func (ec *executionContext) marshalNFoundTribeList2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐFoundTribeList(ctx context.Context, sel ast.SelectionSet, v FoundTribeList) graphql.Marshaler {
	return ec._FoundTribeList(ctx, sel, &v)
}

func (ec *executionContext) marshalNFoundTribeList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐFoundTribeList(ctx context.Context, sel ast.SelectionSet, v *FoundTribeList) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._FoundTribeList(ctx, sel, v)
}

func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
	res, err := graphql.UnmarshalInt(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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) marshalNPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayer(ctx context.Context, sel ast.SelectionSet, v *twmodel.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) marshalNPlayerHistoryRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerHistory(ctx context.Context, sel ast.SelectionSet, v *twmodel.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) marshalNPlayerNameChange2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerNameChangeᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐPlayerNameChange(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNPlayerNameChange2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerNameChange(ctx context.Context, sel ast.SelectionSet, v *twmodel.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) marshalNServer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServer(ctx context.Context, sel ast.SelectionSet, v *twmodel.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ᚋtwᚋtwmodelᚐServerConfig(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfig) graphql.Marshaler {
	return ec._ServerConfig(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigAlly2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigAlly(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigAlly) graphql.Marshaler {
	return ec._ServerConfigAlly(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigBuild2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigBuild(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigBuild) graphql.Marshaler {
	return ec._ServerConfigBuild(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigBuildings2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigBuildings(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigBuildings) graphql.Marshaler {
	return ec._ServerConfigBuildings(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigCommands2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigCommands(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigCommands) graphql.Marshaler {
	return ec._ServerConfigCommands(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigCoord2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigCoord(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigCoord) graphql.Marshaler {
	return ec._ServerConfigCoord(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigGame2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigGame(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigGame) graphql.Marshaler {
	return ec._ServerConfigGame(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigMisc2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigMisc(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigMisc) graphql.Marshaler {
	return ec._ServerConfigMisc(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigNewbie2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigNewbie(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigNewbie) graphql.Marshaler {
	return ec._ServerConfigNewbie(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigNight2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigNight(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigNight) graphql.Marshaler {
	return ec._ServerConfigNight(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigSitter2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigSitter(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigSitter) graphql.Marshaler {
	return ec._ServerConfigSitter(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigSleep2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigSleep(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigSleep) graphql.Marshaler {
	return ec._ServerConfigSleep(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigSnob2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigSnob(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerConfigSnob) graphql.Marshaler {
	return ec._ServerConfigSnob(ctx, sel, &v)
}

func (ec *executionContext) marshalNServerConfigWin2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerConfigWin(ctx context.Context, sel ast.SelectionSet, v twmodel.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) marshalNServerStatsRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStats(ctx context.Context, sel ast.SelectionSet, v *twmodel.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ᚋtwᚋtwmodelᚐServerStatus(ctx context.Context, v interface{}) (twmodel.ServerStatus, error) {
	var res twmodel.ServerStatus
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNServerStatus2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatus(ctx context.Context, sel ast.SelectionSet, v twmodel.ServerStatus) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		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])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
	res, err := graphql.UnmarshalTime(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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) marshalNTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx context.Context, sel ast.SelectionSet, v *twmodel.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) marshalNTribeChangeRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeChange(ctx context.Context, sel ast.SelectionSet, v *twmodel.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) marshalNTribeHistoryRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeHistory(ctx context.Context, sel ast.SelectionSet, v *twmodel.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ᚋtwᚋtwmodelᚐUnit(ctx context.Context, sel ast.SelectionSet, v twmodel.Unit) graphql.Marshaler {
	return ec._Unit(ctx, sel, &v)
}

func (ec *executionContext) marshalNUnitConfig2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐUnitConfig(ctx context.Context, sel ast.SelectionSet, v twmodel.UnitConfig) graphql.Marshaler {
	return ec._UnitConfig(ctx, sel, &v)
}

func (ec *executionContext) marshalNVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersion(ctx context.Context, sel ast.SelectionSet, v *twmodel.Version) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Version(ctx, sel, v)
}

func (ec *executionContext) unmarshalNVersionCode2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCode(ctx context.Context, v interface{}) (twmodel.VersionCode, error) {
	var res twmodel.VersionCode
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNVersionCode2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCode(ctx context.Context, sel ast.SelectionSet, v twmodel.VersionCode) graphql.Marshaler {
	return v
}

func (ec *executionContext) marshalNVersionList2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐVersionList(ctx context.Context, sel ast.SelectionSet, v VersionList) graphql.Marshaler {
	return ec._VersionList(ctx, sel, &v)
}

func (ec *executionContext) marshalNVersionList2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐVersionList(ctx context.Context, sel ast.SelectionSet, v *VersionList) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._VersionList(ctx, sel, v)
}

func (ec *executionContext) marshalNVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVillage(ctx context.Context, sel ast.SelectionSet, v *twmodel.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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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) {
	res, err := graphql.UnmarshalBoolean(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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 := graphql.UnmarshalBoolean(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return graphql.MarshalBoolean(*v)
}

func (ec *executionContext) unmarshalODailyPlayerStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyPlayerStatsFilter(ctx context.Context, v interface{}) (*twmodel.DailyPlayerStatsFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputDailyPlayerStatsFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalODailyPlayerStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyPlayerStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐDailyPlayerStats(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalODailyTribeStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyTribeStatsFilter(ctx context.Context, v interface{}) (*twmodel.DailyTribeStatsFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputDailyTribeStatsFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalODailyTribeStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐDailyTribeStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐDailyTribeStats(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOEnnoblement2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐEnnoblementᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐEnnoblement(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOEnnoblementFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐEnnoblementFilter(ctx context.Context, v interface{}) (*twmodel.EnnoblementFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputEnnoblementFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOEnnoblementFilterOr2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐEnnoblementFilterOr(ctx context.Context, v interface{}) (*twmodel.EnnoblementFilterOr, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputEnnoblementFilterOr(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOFoundPlayer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐFoundPlayerᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.FoundPlayer) 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.marshalNFoundPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐFoundPlayer(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOFoundTribe2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐFoundTribeᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.FoundTribe) 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.marshalNFoundTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐFoundTribe(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
	res, err := graphql.UnmarshalInt(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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) {
	if v == nil {
		return nil, nil
	}
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		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])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalInt(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return graphql.MarshalInt(*v)
}

func (ec *executionContext) marshalOPlayer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐPlayer(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayer(ctx context.Context, sel ast.SelectionSet, v *twmodel.Player) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Player(ctx, sel, v)
}

func (ec *executionContext) unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerFilter(ctx context.Context, v interface{}) (*twmodel.PlayerFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputPlayerFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOPlayerHistoryFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerHistoryFilter(ctx context.Context, v interface{}) (*twmodel.PlayerHistoryFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputPlayerHistoryFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOPlayerHistoryRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐPlayerHistoryᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐPlayerHistory(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOServer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐServer(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOServer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServer(ctx context.Context, sel ast.SelectionSet, v *twmodel.Server) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Server(ctx, sel, v)
}

func (ec *executionContext) unmarshalOServerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerFilter(ctx context.Context, v interface{}) (*twmodel.ServerFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputServerFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOServerStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatsFilter(ctx context.Context, v interface{}) (*twmodel.ServerStatsFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputServerStatsFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOServerStatsRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐServerStats(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatusᚄ(ctx context.Context, v interface{}) ([]twmodel.ServerStatus, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]twmodel.ServerStatus, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNServerStatus2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatus(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐServerStatusᚄ(ctx context.Context, sel ast.SelectionSet, v []twmodel.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ᚋtwᚋtwmodelᚐServerStatus(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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) {
	if v == nil {
		return nil, nil
	}
	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 {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		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])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalString(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return graphql.MarshalString(*v)
}

func (ec *executionContext) unmarshalOTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
	res, err := graphql.UnmarshalTime(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
	return graphql.MarshalTime(v)
}

func (ec *executionContext) marshalOTribe2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐTribe(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribe(ctx context.Context, sel ast.SelectionSet, v *twmodel.Tribe) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Tribe(ctx, sel, v)
}

func (ec *executionContext) unmarshalOTribeChangeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeChangeFilter(ctx context.Context, v interface{}) (*twmodel.TribeChangeFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTribeChangeFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOTribeChangeFilterOr2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeChangeFilterOr(ctx context.Context, v interface{}) (*twmodel.TribeChangeFilterOr, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTribeChangeFilterOr(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOTribeChangeRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeChangeᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐTribeChange(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilter(ctx context.Context, v interface{}) (*twmodel.TribeFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTribeFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOTribeFilterOr2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeFilterOr(ctx context.Context, v interface{}) (*twmodel.TribeFilterOr, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTribeFilterOr(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOTribeHistoryFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeHistoryFilter(ctx context.Context, v interface{}) (*twmodel.TribeHistoryFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTribeHistoryFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOTribeHistoryRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐTribeHistoryᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐTribeHistory(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOVersion2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.Version) 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.marshalNVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersion(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersion(ctx context.Context, sel ast.SelectionSet, v *twmodel.Version) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Version(ctx, sel, v)
}

func (ec *executionContext) unmarshalOVersionCode2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCodeᚄ(ctx context.Context, v interface{}) ([]twmodel.VersionCode, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]twmodel.VersionCode, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNVersionCode2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCode(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOVersionCode2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCodeᚄ(ctx context.Context, sel ast.SelectionSet, v []twmodel.VersionCode) 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.marshalNVersionCode2githubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionCode(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOVersionFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVersionFilter(ctx context.Context, v interface{}) (*twmodel.VersionFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputVersionFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOVillage2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVillageᚄ(ctx context.Context, sel ast.SelectionSet, v []*twmodel.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ᚋtwᚋtwmodelᚐVillage(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalOVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVillage(ctx context.Context, sel ast.SelectionSet, v *twmodel.Village) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Village(ctx, sel, v)
}

func (ec *executionContext) unmarshalOVillageFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋtwᚋtwmodelᚐVillageFilter(ctx context.Context, v interface{}) (*twmodel.VillageFilter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputVillageFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, 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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

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__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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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 *****************************