api/graphql/generated/generated.go

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

package generated

import (
	"bytes"
	"context"
	"errors"
	"github.com/tribalwarshelp/shared/tw/twmodel"
	"strconv"
	"sync"
	"sync/atomic"
	"time"

	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"

	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
		Player     func(childComplexity int) int
		Points     func(childComplexity int) int
		Rank       func(childComplexity int) int
		RankAtt    func(childComplexity int) int
		RankDef    func(childComplexity int) int
		RankSup    func(childComplexity int) int
		RankTotal  func(childComplexity int) int
		ScoreAtt   func(childComplexity int) int
		ScoreDef   func(childComplexity int) int
		ScoreSup   func(childComplexity int) int
		ScoreTotal func(childComplexity int) int
		Villages   func(childComplexity int) int
	}

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

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

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

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

	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
		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
		InactivePlayers   func(childComplexity int) int
		InactiveTribes    func(childComplexity int) int
		PlayerVillages    func(childComplexity int) int
		Players           func(childComplexity int) int
		Tribes            func(childComplexity int) int
		Villages          func(childComplexity int) int
	}

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

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

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

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

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

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

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

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

	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.player":
		if e.complexity.DailyPlayerStatsRecord.Player == nil {
			break
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	case "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.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.inactivePlayers":
		if e.complexity.ServerStatsRecord.InactivePlayers == nil {
			break
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	case "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 {
  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 {
  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 {
  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 {
  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: Int!
  barbarianRise: Float!
  barbarianShrink: Int!
  barbarianMaxPoints: Int!
  hauls: Int!
  haulsBase: Int!
  haulsMax: Int!
  baseProduction: Int!
  event: Int!
  suppressEvents: Int!
}

type ServerConfigBuildings {
  customMain: Int!
  customFarm: Int!
  customStorage: Int!
  customPlace: Int!
  customBarracks: Int!
  customChurch: Int!
  customSmith: Int!
  customWood: Int!
  customStone: Int!
  customIron: Int!
  customMarket: Int!
  customStable: Int!
  customWall: Int!
  customGarage: Int!
  customHide: Int!
  customSnob: Int!
  customStatue: Int!
  customWatchtower: Int!
}

type ServerConfigSnob {
  gold: Int!
  cheapRebuild: Int!
  rise: Int!
  maxDist: Int!
  factor: Float!
  coinWood: Int!
  coinStone: Int!
  coinIron: Int!
  noBarbConquer: Boolean!
}

type ServerConfigAlly {
  noHarm: Int!
  noOtherSupport: Int!
  allytimeSupport: Int!
  noLeave: Int!
  noJoin: Int!
  limit: Int!
  fixedAllies: Int!
  pointsMemberCount: Int!
  warsMemberRequirement: Int!
  warsPointsRequirement: Int!
  warsAutoacceptDays: Int!
  levels: Int!
  xpRequirements: String!
}

type ServerConfigCoord {
  mapSize: Int!
  func: Int!
  emptyVillages: Int!
  bonusVillages: Int!
  bonusNew: Int!
  inner: Int!
  selectStart: Int!
  villageMoveWait: Int!
  nobleRestart: Int!
  startVillages: Int!
}

type ServerConfigSitter {
  allow: Int!
}

type ServerConfigSleep {
  active: Int!
  delay: Int!
  min: Int!
  max: Int!
  minAwake: Int!
  maxAwake: Int!
  warnTime: Int!
}

type ServerConfigNight {
  active: Int!
  startHour: Int!
  endHour: Int!
  defFactor: Float!
}

type ServerConfigWin {
  check: Int!
}

type ServerConfig {
  speed: Float!
  unitSpeed: Float!
  moral: Int!
  build: ServerConfigBuild!
  misc: ServerConfigMisc!
  commands: ServerConfigCommands!
  newbie: ServerConfigNewbie!
  game: ServerConfigGame!
  buildings: ServerConfigBuildings!
  snob: ServerConfigSnob!
  ally: ServerConfigAlly!
  coord: ServerConfigCoord!
  sitter: ServerConfigSitter!
  sleep: ServerConfigSleep!
  night: ServerConfigNight!
  win: ServerConfigWin!
}
`, BuiltIn: false},
	{Name: "schema/server_stats.graphql", Input: `type ServerStatsRecord {
  activePlayers: Int!
  inactivePlayers: Int!
  players: Int!
  activeTribes: Int!
  inactiveTribes: Int!
  tribes: Int!
  bonusVillages: Int!
  barbarianVillages: Int!
  playerVillages: Int!
  villages: Int!
  createDate: Time!
}

type ServerStats {
  items: [ServerStatsRecord!]
  total: Int!
}

input ServerStatsFilter {
  createDate: Time
  createDateGT: Time
  createDateGTE: Time
  createDateLT: Time
  createDateLTE: Time
}

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 {
  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 {
  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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐBuilding(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(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ᚋmodelsᚐDailyPlayerStatsᚄ(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ᚋmodelsᚐ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ᚋmodelsᚐDailyTribeStatsᚄ(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ᚋmodelsᚐ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_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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐEnnoblementᚄ(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐPlayerNameChangeᚄ(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(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ᚋmodelsᚐPlayerHistoryᚄ(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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐPlayerᚄ(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(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ᚋmodelsᚐ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ᚋmodelsᚐServer(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_serverStats(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐVillage(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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.(int)
	fc.Result = res
	return ec.marshalNInt2int(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ᚋmodelsᚐServerᚄ(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(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ᚋmodelsᚐServerStatsᚄ(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Total, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ServerStatsRecord_activePlayers(ctx context.Context, field graphql.CollectedField, obj *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_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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐTribeChangeᚄ(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(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ᚋmodelsᚐTribeHistoryᚄ(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ᚋmodelsᚐ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ᚋmodelsᚐTribeᚄ(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐPlayer(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(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ᚋmodelsᚐVillageᚄ(ctx, field.Selections, res)
}

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

	ctx = graphql.WithFieldContext(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) ___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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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ᚋmodelsᚐ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
	var asMap = obj.(map[string]interface{})

	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ᚋmodelsᚐ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 "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 "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 "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 "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 "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 "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 "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++
			}
		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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐPlayerNameChange(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNPlayerNameChange2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayerNameChange(ctx context.Context, sel ast.SelectionSet, v *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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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])
	}

	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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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()
	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()
	return ret
}

func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
	return ec.___EnumValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
	return ec.___Field(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
	return ec.___InputValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
	return ec.___Type(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
	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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐDailyPlayerStats(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalODailyTribeStatsFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐDailyTribeStats(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOEnnoblement2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐEnnoblementᚄ(ctx context.Context, sel ast.SelectionSet, v []*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ᚋmodelsᚐEnnoblement(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOEnnoblementFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐFoundPlayer(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOFoundTribe2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐFoundTribe(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	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])
	}

	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ᚋmodelsᚐ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ᚋmodelsᚐPlayer(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx context.Context, sel ast.SelectionSet, v *twmodel.Player) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Player(ctx, sel, v)
}

func (ec *executionContext) unmarshalOPlayerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐPlayerHistory(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOServer2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerᚄ(ctx context.Context, sel ast.SelectionSet, v []*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ᚋmodelsᚐServer(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOServer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServer(ctx context.Context, sel ast.SelectionSet, v *twmodel.Server) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Server(ctx, sel, v)
}

func (ec *executionContext) unmarshalOServerFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐServerStats(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatusᚄ(ctx context.Context, v interface{}) ([]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ᚋmodelsᚐServerStatus(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOServerStatus2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐServerStatusᚄ(ctx context.Context, sel ast.SelectionSet, v []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ᚋmodelsᚐServerStatus(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
	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])
	}

	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ᚋmodelsᚐ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ᚋmodelsᚐTribe(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx context.Context, sel ast.SelectionSet, v *twmodel.Tribe) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Tribe(ctx, sel, v)
}

func (ec *executionContext) unmarshalOTribeChangeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐTribeChange(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOTribeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐTribeHistory(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOVersion2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐVersion(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOVersion2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐVersionCode(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOVersionCode2ᚕgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐVersionCode(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOVersionFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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ᚋmodelsᚐ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ᚋmodelsᚐVillage(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOVillage2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐVillage(ctx context.Context, sel ast.SelectionSet, v *twmodel.Village) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Village(ctx, sel, v)
}

func (ec *executionContext) unmarshalOVillageFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐ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()
	return ret
}

func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__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()
	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 *****************************