analysis.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: analysis.proto

package otsimopb

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type QuerySort_SortOrder int32

const (
	QuerySort_ASC QuerySort_SortOrder = 0
	QuerySort_DSC QuerySort_SortOrder = 1
)

var QuerySort_SortOrder_name = map[int32]string{
	0: "ASC",
	1: "DSC",
}

var QuerySort_SortOrder_value = map[string]int32{
	"ASC": 0,
	"DSC": 1,
}

func (x QuerySort_SortOrder) String() string {
	return proto.EnumName(QuerySort_SortOrder_name, int32(x))
}

func (QuerySort_SortOrder) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{5, 0}
}

type Aggregation_Accumulator int32

const (
	Aggregation_NONE     Aggregation_Accumulator = 0
	Aggregation_COUNT    Aggregation_Accumulator = 1
	Aggregation_SUM      Aggregation_Accumulator = 2
	Aggregation_MAX      Aggregation_Accumulator = 3
	Aggregation_MIN      Aggregation_Accumulator = 4
	Aggregation_AVG      Aggregation_Accumulator = 5
	Aggregation_STD_SAMP Aggregation_Accumulator = 6
	Aggregation_STD_POP  Aggregation_Accumulator = 7
)

var Aggregation_Accumulator_name = map[int32]string{
	0: "NONE",
	1: "COUNT",
	2: "SUM",
	3: "MAX",
	4: "MIN",
	5: "AVG",
	6: "STD_SAMP",
	7: "STD_POP",
}

var Aggregation_Accumulator_value = map[string]int32{
	"NONE":     0,
	"COUNT":    1,
	"SUM":      2,
	"MAX":      3,
	"MIN":      4,
	"AVG":      5,
	"STD_SAMP": 6,
	"STD_POP":  7,
}

func (x Aggregation_Accumulator) String() string {
	return proto.EnumName(Aggregation_Accumulator_name, int32(x))
}

func (Aggregation_Accumulator) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{6, 0}
}

type QueryGroup_GroupType int32

const (
	// Date gives rows each day of given timeRange
	QueryGroup_Date QueryGroup_GroupType = 0
	// Datetime gives rows on given interval
	QueryGroup_Datetime QueryGroup_GroupType = 1
	// TimeofDay gives rows on time of day. minutes and seconds on interval
	// value determines interval. ex: if minutes and seconds are false then rows
	// will be 0,1,2,3,4 ex: if minutes is true then rows will be
	// 00:00,00:01,00:02,... when seconds is true than minutes is always true
	QueryGroup_TimeOfDay QueryGroup_GroupType = 2
	// Discrete should be used for String values
	QueryGroup_Discrete QueryGroup_GroupType = 3
	// ContinuesInterval is for number values
	QueryGroup_ContinuesInterval QueryGroup_GroupType = 4
)

var QueryGroup_GroupType_name = map[int32]string{
	0: "Date",
	1: "Datetime",
	2: "TimeOfDay",
	3: "Discrete",
	4: "ContinuesInterval",
}

var QueryGroup_GroupType_value = map[string]int32{
	"Date":              0,
	"Datetime":          1,
	"TimeOfDay":         2,
	"Discrete":          3,
	"ContinuesInterval": 4,
}

func (x QueryGroup_GroupType) String() string {
	return proto.EnumName(QueryGroup_GroupType_name, int32(x))
}

func (QueryGroup_GroupType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{8, 0}
}

type ActiveUsersRequest_Type int32

const (
	ActiveUsersRequest_MONTLY ActiveUsersRequest_Type = 0
	ActiveUsersRequest_DAILY  ActiveUsersRequest_Type = 1
	ActiveUsersRequest_NEW    ActiveUsersRequest_Type = 2
	ActiveUsersRequest_TOTAL  ActiveUsersRequest_Type = 3
)

var ActiveUsersRequest_Type_name = map[int32]string{
	0: "MONTLY",
	1: "DAILY",
	2: "NEW",
	3: "TOTAL",
}

var ActiveUsersRequest_Type_value = map[string]int32{
	"MONTLY": 0,
	"DAILY":  1,
	"NEW":    2,
	"TOTAL":  3,
}

func (x ActiveUsersRequest_Type) String() string {
	return proto.EnumName(ActiveUsersRequest_Type_name, int32(x))
}

func (ActiveUsersRequest_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{12, 0}
}

type RetentionRequest_Type int32

const (
	RetentionRequest_ONE    RetentionRequest_Type = 0
	RetentionRequest_SEVEN  RetentionRequest_Type = 1
	RetentionRequest_THIRTY RetentionRequest_Type = 2
)

var RetentionRequest_Type_name = map[int32]string{
	0: "ONE",
	1: "SEVEN",
	2: "THIRTY",
}

var RetentionRequest_Type_value = map[string]int32{
	"ONE":    0,
	"SEVEN":  1,
	"THIRTY": 2,
}

func (x RetentionRequest_Type) String() string {
	return proto.EnumName(RetentionRequest_Type_name, int32(x))
}

func (RetentionRequest_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{14, 0}
}

type GameInfoResponse_FieldType int32

const (
	GameInfoResponse_UNKNOWN GameInfoResponse_FieldType = 0
	GameInfoResponse_STRING  GameInfoResponse_FieldType = 1
	GameInfoResponse_INTEGER GameInfoResponse_FieldType = 2
	GameInfoResponse_FLOAT   GameInfoResponse_FieldType = 3
	GameInfoResponse_BOOL    GameInfoResponse_FieldType = 4
)

var GameInfoResponse_FieldType_name = map[int32]string{
	0: "UNKNOWN",
	1: "STRING",
	2: "INTEGER",
	3: "FLOAT",
	4: "BOOL",
}

var GameInfoResponse_FieldType_value = map[string]int32{
	"UNKNOWN": 0,
	"STRING":  1,
	"INTEGER": 2,
	"FLOAT":   3,
	"BOOL":    4,
}

func (x GameInfoResponse_FieldType) String() string {
	return proto.EnumName(GameInfoResponse_FieldType_name, int32(x))
}

func (GameInfoResponse_FieldType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{19, 0}
}

type TimeRange struct {
	// From is the unix seconds time
	From int64 `protobuf:"varint,1,opt,name=from,proto3" json:"from,omitempty"`
	// To is the unix seconds time
	To                   int64    `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TimeRange) Reset()         { *m = TimeRange{} }
func (m *TimeRange) String() string { return proto.CompactTextString(m) }
func (*TimeRange) ProtoMessage()    {}
func (*TimeRange) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{0}
}
func (m *TimeRange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TimeRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TimeRange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TimeRange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TimeRange.Merge(m, src)
}
func (m *TimeRange) XXX_Size() int {
	return m.Size()
}
func (m *TimeRange) XXX_DiscardUnknown() {
	xxx_messageInfo_TimeRange.DiscardUnknown(m)
}

var xxx_messageInfo_TimeRange proto.InternalMessageInfo

func (m *TimeRange) GetFrom() int64 {
	if m != nil {
		return m.From
	}
	return 0
}

func (m *TimeRange) GetTo() int64 {
	if m != nil {
		return m.To
	}
	return 0
}

type ChildAndProfileIds struct {
	// ChildId
	ChildId string `protobuf:"bytes,1,opt,name=child_id,json=childId,proto3" json:"child_id,omitempty"`
	// ProfileId
	ProfileId            string   `protobuf:"bytes,2,opt,name=profile_id,json=profileId,proto3" json:"profile_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChildAndProfileIds) Reset()         { *m = ChildAndProfileIds{} }
func (m *ChildAndProfileIds) String() string { return proto.CompactTextString(m) }
func (*ChildAndProfileIds) ProtoMessage()    {}
func (*ChildAndProfileIds) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{1}
}
func (m *ChildAndProfileIds) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChildAndProfileIds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ChildAndProfileIds.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ChildAndProfileIds) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChildAndProfileIds.Merge(m, src)
}
func (m *ChildAndProfileIds) XXX_Size() int {
	return m.Size()
}
func (m *ChildAndProfileIds) XXX_DiscardUnknown() {
	xxx_messageInfo_ChildAndProfileIds.DiscardUnknown(m)
}

var xxx_messageInfo_ChildAndProfileIds proto.InternalMessageInfo

func (m *ChildAndProfileIds) GetChildId() string {
	if m != nil {
		return m.ChildId
	}
	return ""
}

func (m *ChildAndProfileIds) GetProfileId() string {
	if m != nil {
		return m.ProfileId
	}
	return ""
}

type ChildAndTimeRange struct {
	// ChildId
	ChildId string `protobuf:"bytes,1,opt,name=child_id,json=childId,proto3" json:"child_id,omitempty"`
	// ProfileId
	ProfileId string `protobuf:"bytes,2,opt,name=profile_id,json=profileId,proto3" json:"profile_id,omitempty"`
	// Range is the time range
	Range                *TimeRange `protobuf:"bytes,3,opt,name=range,proto3" json:"range,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ChildAndTimeRange) Reset()         { *m = ChildAndTimeRange{} }
func (m *ChildAndTimeRange) String() string { return proto.CompactTextString(m) }
func (*ChildAndTimeRange) ProtoMessage()    {}
func (*ChildAndTimeRange) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{2}
}
func (m *ChildAndTimeRange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChildAndTimeRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ChildAndTimeRange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ChildAndTimeRange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChildAndTimeRange.Merge(m, src)
}
func (m *ChildAndTimeRange) XXX_Size() int {
	return m.Size()
}
func (m *ChildAndTimeRange) XXX_DiscardUnknown() {
	xxx_messageInfo_ChildAndTimeRange.DiscardUnknown(m)
}

var xxx_messageInfo_ChildAndTimeRange proto.InternalMessageInfo

func (m *ChildAndTimeRange) GetChildId() string {
	if m != nil {
		return m.ChildId
	}
	return ""
}

func (m *ChildAndTimeRange) GetProfileId() string {
	if m != nil {
		return m.ProfileId
	}
	return ""
}

func (m *ChildAndTimeRange) GetRange() *TimeRange {
	if m != nil {
		return m.Range
	}
	return nil
}

type GameWithVersions struct {
	// GameId
	GameId string `protobuf:"bytes,1,opt,name=game_id,json=gameId,proto3" json:"game_id,omitempty"`
	// Versions
	Versions             []string `protobuf:"bytes,2,rep,name=versions,proto3" json:"versions,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GameWithVersions) Reset()         { *m = GameWithVersions{} }
func (m *GameWithVersions) String() string { return proto.CompactTextString(m) }
func (*GameWithVersions) ProtoMessage()    {}
func (*GameWithVersions) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{3}
}
func (m *GameWithVersions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GameWithVersions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GameWithVersions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GameWithVersions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GameWithVersions.Merge(m, src)
}
func (m *GameWithVersions) XXX_Size() int {
	return m.Size()
}
func (m *GameWithVersions) XXX_DiscardUnknown() {
	xxx_messageInfo_GameWithVersions.DiscardUnknown(m)
}

var xxx_messageInfo_GameWithVersions proto.InternalMessageInfo

func (m *GameWithVersions) GetGameId() string {
	if m != nil {
		return m.GameId
	}
	return ""
}

func (m *GameWithVersions) GetVersions() []string {
	if m != nil {
		return m.Versions
	}
	return nil
}

type PlayedGamesList struct {
	Games []*GameWithVersions `protobuf:"bytes,1,rep,name=games,proto3" json:"games,omitempty"`
	// ChildId
	ChildId string `protobuf:"bytes,2,opt,name=child_id,json=childId,proto3" json:"child_id,omitempty"`
	// Range is the time range
	Range                *TimeRange `protobuf:"bytes,3,opt,name=range,proto3" json:"range,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *PlayedGamesList) Reset()         { *m = PlayedGamesList{} }
func (m *PlayedGamesList) String() string { return proto.CompactTextString(m) }
func (*PlayedGamesList) ProtoMessage()    {}
func (*PlayedGamesList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{4}
}
func (m *PlayedGamesList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PlayedGamesList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PlayedGamesList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PlayedGamesList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PlayedGamesList.Merge(m, src)
}
func (m *PlayedGamesList) XXX_Size() int {
	return m.Size()
}
func (m *PlayedGamesList) XXX_DiscardUnknown() {
	xxx_messageInfo_PlayedGamesList.DiscardUnknown(m)
}

var xxx_messageInfo_PlayedGamesList proto.InternalMessageInfo

func (m *PlayedGamesList) GetGames() []*GameWithVersions {
	if m != nil {
		return m.Games
	}
	return nil
}

func (m *PlayedGamesList) GetChildId() string {
	if m != nil {
		return m.ChildId
	}
	return ""
}

func (m *PlayedGamesList) GetRange() *TimeRange {
	if m != nil {
		return m.Range
	}
	return nil
}

type QuerySort struct {
	FieldName            string              `protobuf:"bytes,1,opt,name=field_name,json=fieldName,proto3" json:"field_name,omitempty"`
	Order                QuerySort_SortOrder `protobuf:"varint,2,opt,name=order,proto3,enum=apipb.QuerySort_SortOrder" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *QuerySort) Reset()         { *m = QuerySort{} }
func (m *QuerySort) String() string { return proto.CompactTextString(m) }
func (*QuerySort) ProtoMessage()    {}
func (*QuerySort) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{5}
}
func (m *QuerySort) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QuerySort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QuerySort.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QuerySort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QuerySort.Merge(m, src)
}
func (m *QuerySort) XXX_Size() int {
	return m.Size()
}
func (m *QuerySort) XXX_DiscardUnknown() {
	xxx_messageInfo_QuerySort.DiscardUnknown(m)
}

var xxx_messageInfo_QuerySort proto.InternalMessageInfo

func (m *QuerySort) GetFieldName() string {
	if m != nil {
		return m.FieldName
	}
	return ""
}

func (m *QuerySort) GetOrder() QuerySort_SortOrder {
	if m != nil {
		return m.Order
	}
	return QuerySort_ASC
}

type Aggregation struct {
	FieldName            string                  `protobuf:"bytes,1,opt,name=field_name,json=fieldName,proto3" json:"field_name,omitempty"`
	OutputField          string                  `protobuf:"bytes,2,opt,name=output_field,json=outputField,proto3" json:"output_field,omitempty"`
	Accumulator          Aggregation_Accumulator `protobuf:"varint,3,opt,name=accumulator,proto3,enum=apipb.Aggregation_Accumulator" json:"accumulator,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *Aggregation) Reset()         { *m = Aggregation{} }
func (m *Aggregation) String() string { return proto.CompactTextString(m) }
func (*Aggregation) ProtoMessage()    {}
func (*Aggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{6}
}
func (m *Aggregation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Aggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Aggregation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Aggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Aggregation.Merge(m, src)
}
func (m *Aggregation) XXX_Size() int {
	return m.Size()
}
func (m *Aggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_Aggregation.DiscardUnknown(m)
}

var xxx_messageInfo_Aggregation proto.InternalMessageInfo

func (m *Aggregation) GetFieldName() string {
	if m != nil {
		return m.FieldName
	}
	return ""
}

func (m *Aggregation) GetOutputField() string {
	if m != nil {
		return m.OutputField
	}
	return ""
}

func (m *Aggregation) GetAccumulator() Aggregation_Accumulator {
	if m != nil {
		return m.Accumulator
	}
	return Aggregation_NONE
}

type GroupInterval struct {
	// For ContinuesInterval
	Int int32 `protobuf:"varint,1,opt,name=int,proto3" json:"int,omitempty"`
	// For ContinuesInterval
	Real float32 `protobuf:"fixed32,2,opt,name=real,proto3" json:"real,omitempty"`
	// For Datetime
	Days int32 `protobuf:"varint,3,opt,name=days,proto3" json:"days,omitempty"`
	// For Datetime
	Hours int32 `protobuf:"varint,4,opt,name=hours,proto3" json:"hours,omitempty"`
	// For TimeOfDay
	Minutes bool `protobuf:"varint,5,opt,name=minutes,proto3" json:"minutes,omitempty"`
	// For TimeOfDay
	Seconds              bool     `protobuf:"varint,6,opt,name=seconds,proto3" json:"seconds,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GroupInterval) Reset()         { *m = GroupInterval{} }
func (m *GroupInterval) String() string { return proto.CompactTextString(m) }
func (*GroupInterval) ProtoMessage()    {}
func (*GroupInterval) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{7}
}
func (m *GroupInterval) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GroupInterval) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GroupInterval.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GroupInterval) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupInterval.Merge(m, src)
}
func (m *GroupInterval) XXX_Size() int {
	return m.Size()
}
func (m *GroupInterval) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupInterval.DiscardUnknown(m)
}

var xxx_messageInfo_GroupInterval proto.InternalMessageInfo

func (m *GroupInterval) GetInt() int32 {
	if m != nil {
		return m.Int
	}
	return 0
}

func (m *GroupInterval) GetReal() float32 {
	if m != nil {
		return m.Real
	}
	return 0
}

func (m *GroupInterval) GetDays() int32 {
	if m != nil {
		return m.Days
	}
	return 0
}

func (m *GroupInterval) GetHours() int32 {
	if m != nil {
		return m.Hours
	}
	return 0
}

func (m *GroupInterval) GetMinutes() bool {
	if m != nil {
		return m.Minutes
	}
	return false
}

func (m *GroupInterval) GetSeconds() bool {
	if m != nil {
		return m.Seconds
	}
	return false
}

type QueryGroup struct {
	FieldName string               `protobuf:"bytes,1,opt,name=field_name,json=fieldName,proto3" json:"field_name,omitempty"`
	Type      QueryGroup_GroupType `protobuf:"varint,2,opt,name=type,proto3,enum=apipb.QueryGroup_GroupType" json:"type,omitempty"`
	// Interval is optional for Date and Discrete type
	Interval    *GroupInterval `protobuf:"bytes,3,opt,name=interval,proto3" json:"interval,omitempty"`
	OutputField string         `protobuf:"bytes,4,opt,name=output_field,json=outputField,proto3" json:"output_field,omitempty"`
	// Timezone Offset in seconds
	TimezoneSeconds      int32    `protobuf:"varint,5,opt,name=timezone_seconds,json=timezoneSeconds,proto3" json:"timezone_seconds,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *QueryGroup) Reset()         { *m = QueryGroup{} }
func (m *QueryGroup) String() string { return proto.CompactTextString(m) }
func (*QueryGroup) ProtoMessage()    {}
func (*QueryGroup) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{8}
}
func (m *QueryGroup) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryGroup.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryGroup) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryGroup.Merge(m, src)
}
func (m *QueryGroup) XXX_Size() int {
	return m.Size()
}
func (m *QueryGroup) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryGroup.DiscardUnknown(m)
}

var xxx_messageInfo_QueryGroup proto.InternalMessageInfo

func (m *QueryGroup) GetFieldName() string {
	if m != nil {
		return m.FieldName
	}
	return ""
}

func (m *QueryGroup) GetType() QueryGroup_GroupType {
	if m != nil {
		return m.Type
	}
	return QueryGroup_Date
}

func (m *QueryGroup) GetInterval() *GroupInterval {
	if m != nil {
		return m.Interval
	}
	return nil
}

func (m *QueryGroup) GetOutputField() string {
	if m != nil {
		return m.OutputField
	}
	return ""
}

func (m *QueryGroup) GetTimezoneSeconds() int32 {
	if m != nil {
		return m.TimezoneSeconds
	}
	return 0
}

type Query struct {
	Events               []string       `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	Range                *TimeRange     `protobuf:"bytes,2,opt,name=range,proto3" json:"range,omitempty"`
	Sort                 []*QuerySort   `protobuf:"bytes,3,rep,name=sort,proto3" json:"sort,omitempty"`
	Limit                int32          `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	Offset               int32          `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"`
	GroupBy              *QueryGroup    `protobuf:"bytes,6,opt,name=group_by,json=groupBy,proto3" json:"group_by,omitempty"`
	Aggregations         []*Aggregation `protobuf:"bytes,7,rep,name=aggregations,proto3" json:"aggregations,omitempty"`
	RawQueries           [][]byte       `protobuf:"bytes,8,rep,name=raw_queries,json=rawQueries,proto3" json:"raw_queries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *Query) Reset()         { *m = Query{} }
func (m *Query) String() string { return proto.CompactTextString(m) }
func (*Query) ProtoMessage()    {}
func (*Query) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{9}
}
func (m *Query) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Query.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Query) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Query.Merge(m, src)
}
func (m *Query) XXX_Size() int {
	return m.Size()
}
func (m *Query) XXX_DiscardUnknown() {
	xxx_messageInfo_Query.DiscardUnknown(m)
}

var xxx_messageInfo_Query proto.InternalMessageInfo

func (m *Query) GetEvents() []string {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *Query) GetRange() *TimeRange {
	if m != nil {
		return m.Range
	}
	return nil
}

func (m *Query) GetSort() []*QuerySort {
	if m != nil {
		return m.Sort
	}
	return nil
}

func (m *Query) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *Query) GetOffset() int32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *Query) GetGroupBy() *QueryGroup {
	if m != nil {
		return m.GroupBy
	}
	return nil
}

func (m *Query) GetAggregations() []*Aggregation {
	if m != nil {
		return m.Aggregations
	}
	return nil
}

func (m *Query) GetRawQueries() [][]byte {
	if m != nil {
		return m.RawQueries
	}
	return nil
}

type AnalyzeRequest struct {
	// ChildId
	ChildId string `protobuf:"bytes,1,opt,name=child_id,json=childId,proto3" json:"child_id,omitempty"`
	// ProfileId
	ProfileId string `protobuf:"bytes,2,opt,name=profile_id,json=profileId,proto3" json:"profile_id,omitempty"`
	// UseAppData changes data source
	UseAppData bool `protobuf:"varint,3,opt,name=use_app_data,json=useAppData,proto3" json:"use_app_data,omitempty"`
	// Query is calculation query
	Query *Query `protobuf:"bytes,6,opt,name=query,proto3" json:"query,omitempty"`
	// Games are the compute this request on
	Games                []*GameWithVersions `protobuf:"bytes,7,rep,name=games,proto3" json:"games,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *AnalyzeRequest) Reset()         { *m = AnalyzeRequest{} }
func (m *AnalyzeRequest) String() string { return proto.CompactTextString(m) }
func (*AnalyzeRequest) ProtoMessage()    {}
func (*AnalyzeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{10}
}
func (m *AnalyzeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalyzeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AnalyzeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AnalyzeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalyzeRequest.Merge(m, src)
}
func (m *AnalyzeRequest) XXX_Size() int {
	return m.Size()
}
func (m *AnalyzeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalyzeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AnalyzeRequest proto.InternalMessageInfo

func (m *AnalyzeRequest) GetChildId() string {
	if m != nil {
		return m.ChildId
	}
	return ""
}

func (m *AnalyzeRequest) GetProfileId() string {
	if m != nil {
		return m.ProfileId
	}
	return ""
}

func (m *AnalyzeRequest) GetUseAppData() bool {
	if m != nil {
		return m.UseAppData
	}
	return false
}

func (m *AnalyzeRequest) GetQuery() *Query {
	if m != nil {
		return m.Query
	}
	return nil
}

func (m *AnalyzeRequest) GetGames() []*GameWithVersions {
	if m != nil {
		return m.Games
	}
	return nil
}

type AnalyzeResult struct {
	// Request
	Request *AnalyzeRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	// Data
	Data *DataSet `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// Created At
	CreatedAt            int64    `protobuf:"varint,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AnalyzeResult) Reset()         { *m = AnalyzeResult{} }
func (m *AnalyzeResult) String() string { return proto.CompactTextString(m) }
func (*AnalyzeResult) ProtoMessage()    {}
func (*AnalyzeResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{11}
}
func (m *AnalyzeResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnalyzeResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AnalyzeResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AnalyzeResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalyzeResult.Merge(m, src)
}
func (m *AnalyzeResult) XXX_Size() int {
	return m.Size()
}
func (m *AnalyzeResult) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalyzeResult.DiscardUnknown(m)
}

var xxx_messageInfo_AnalyzeResult proto.InternalMessageInfo

func (m *AnalyzeResult) GetRequest() *AnalyzeRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *AnalyzeResult) GetData() *DataSet {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *AnalyzeResult) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

// Active Users
type ActiveUsersRequest struct {
	Type                 ActiveUsersRequest_Type `protobuf:"varint,1,opt,name=type,proto3,enum=apipb.ActiveUsersRequest_Type" json:"type,omitempty"`
	Dates                []int64                 `protobuf:"varint,2,rep,packed,name=dates,proto3" json:"dates,omitempty"`
	AppId                string                  `protobuf:"bytes,3,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *ActiveUsersRequest) Reset()         { *m = ActiveUsersRequest{} }
func (m *ActiveUsersRequest) String() string { return proto.CompactTextString(m) }
func (*ActiveUsersRequest) ProtoMessage()    {}
func (*ActiveUsersRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{12}
}
func (m *ActiveUsersRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ActiveUsersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ActiveUsersRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ActiveUsersRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ActiveUsersRequest.Merge(m, src)
}
func (m *ActiveUsersRequest) XXX_Size() int {
	return m.Size()
}
func (m *ActiveUsersRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ActiveUsersRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ActiveUsersRequest proto.InternalMessageInfo

func (m *ActiveUsersRequest) GetType() ActiveUsersRequest_Type {
	if m != nil {
		return m.Type
	}
	return ActiveUsersRequest_MONTLY
}

func (m *ActiveUsersRequest) GetDates() []int64 {
	if m != nil {
		return m.Dates
	}
	return nil
}

func (m *ActiveUsersRequest) GetAppId() string {
	if m != nil {
		return m.AppId
	}
	return ""
}

type ActiveUsersResult struct {
	// Request
	Request *ActiveUsersRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	// Data
	Data *DataSet `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// Created At
	CreatedAt            int64    `protobuf:"varint,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ActiveUsersResult) Reset()         { *m = ActiveUsersResult{} }
func (m *ActiveUsersResult) String() string { return proto.CompactTextString(m) }
func (*ActiveUsersResult) ProtoMessage()    {}
func (*ActiveUsersResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{13}
}
func (m *ActiveUsersResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ActiveUsersResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ActiveUsersResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ActiveUsersResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ActiveUsersResult.Merge(m, src)
}
func (m *ActiveUsersResult) XXX_Size() int {
	return m.Size()
}
func (m *ActiveUsersResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ActiveUsersResult.DiscardUnknown(m)
}

var xxx_messageInfo_ActiveUsersResult proto.InternalMessageInfo

func (m *ActiveUsersResult) GetRequest() *ActiveUsersRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *ActiveUsersResult) GetData() *DataSet {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ActiveUsersResult) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

// Retention
type RetentionRequest struct {
	Type                 RetentionRequest_Type `protobuf:"varint,1,opt,name=type,proto3,enum=apipb.RetentionRequest_Type" json:"type,omitempty"`
	Dates                []int64               `protobuf:"varint,2,rep,packed,name=dates,proto3" json:"dates,omitempty"`
	AppId                string                `protobuf:"bytes,3,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *RetentionRequest) Reset()         { *m = RetentionRequest{} }
func (m *RetentionRequest) String() string { return proto.CompactTextString(m) }
func (*RetentionRequest) ProtoMessage()    {}
func (*RetentionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{14}
}
func (m *RetentionRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RetentionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RetentionRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RetentionRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RetentionRequest.Merge(m, src)
}
func (m *RetentionRequest) XXX_Size() int {
	return m.Size()
}
func (m *RetentionRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RetentionRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RetentionRequest proto.InternalMessageInfo

func (m *RetentionRequest) GetType() RetentionRequest_Type {
	if m != nil {
		return m.Type
	}
	return RetentionRequest_ONE
}

func (m *RetentionRequest) GetDates() []int64 {
	if m != nil {
		return m.Dates
	}
	return nil
}

func (m *RetentionRequest) GetAppId() string {
	if m != nil {
		return m.AppId
	}
	return ""
}

type RetentionResult struct {
	// Request
	Request *RetentionRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	// Data
	Data *DataSet `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// Created At
	CreatedAt            int64    `protobuf:"varint,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RetentionResult) Reset()         { *m = RetentionResult{} }
func (m *RetentionResult) String() string { return proto.CompactTextString(m) }
func (*RetentionResult) ProtoMessage()    {}
func (*RetentionResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{15}
}
func (m *RetentionResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RetentionResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RetentionResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RetentionResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RetentionResult.Merge(m, src)
}
func (m *RetentionResult) XXX_Size() int {
	return m.Size()
}
func (m *RetentionResult) XXX_DiscardUnknown() {
	xxx_messageInfo_RetentionResult.DiscardUnknown(m)
}

var xxx_messageInfo_RetentionResult proto.InternalMessageInfo

func (m *RetentionResult) GetRequest() *RetentionRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *RetentionResult) GetData() *DataSet {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *RetentionResult) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

type InactiveUsersRequest struct {
	AppId                string     `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	InactiveDuring       *TimeRange `protobuf:"bytes,2,opt,name=inactive_during,json=inactiveDuring,proto3" json:"inactive_during,omitempty"`
	ActiveDuring         *TimeRange `protobuf:"bytes,3,opt,name=active_during,json=activeDuring,proto3" json:"active_during,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *InactiveUsersRequest) Reset()         { *m = InactiveUsersRequest{} }
func (m *InactiveUsersRequest) String() string { return proto.CompactTextString(m) }
func (*InactiveUsersRequest) ProtoMessage()    {}
func (*InactiveUsersRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{16}
}
func (m *InactiveUsersRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InactiveUsersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InactiveUsersRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InactiveUsersRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InactiveUsersRequest.Merge(m, src)
}
func (m *InactiveUsersRequest) XXX_Size() int {
	return m.Size()
}
func (m *InactiveUsersRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_InactiveUsersRequest.DiscardUnknown(m)
}

var xxx_messageInfo_InactiveUsersRequest proto.InternalMessageInfo

func (m *InactiveUsersRequest) GetAppId() string {
	if m != nil {
		return m.AppId
	}
	return ""
}

func (m *InactiveUsersRequest) GetInactiveDuring() *TimeRange {
	if m != nil {
		return m.InactiveDuring
	}
	return nil
}

func (m *InactiveUsersRequest) GetActiveDuring() *TimeRange {
	if m != nil {
		return m.ActiveDuring
	}
	return nil
}

type GetActiveUsersRequest struct {
	AppId                string     `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	Period               *TimeRange `protobuf:"bytes,2,opt,name=period,proto3" json:"period,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GetActiveUsersRequest) Reset()         { *m = GetActiveUsersRequest{} }
func (m *GetActiveUsersRequest) String() string { return proto.CompactTextString(m) }
func (*GetActiveUsersRequest) ProtoMessage()    {}
func (*GetActiveUsersRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{17}
}
func (m *GetActiveUsersRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetActiveUsersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetActiveUsersRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetActiveUsersRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetActiveUsersRequest.Merge(m, src)
}
func (m *GetActiveUsersRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetActiveUsersRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetActiveUsersRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetActiveUsersRequest proto.InternalMessageInfo

func (m *GetActiveUsersRequest) GetAppId() string {
	if m != nil {
		return m.AppId
	}
	return ""
}

func (m *GetActiveUsersRequest) GetPeriod() *TimeRange {
	if m != nil {
		return m.Period
	}
	return nil
}

type ActiveOnRangeRequest struct {
	Range                *TimeRange `protobuf:"bytes,1,opt,name=range,proto3" json:"range,omitempty"`
	CountryCodes         []string   `protobuf:"bytes,2,rep,name=country_codes,json=countryCodes,proto3" json:"country_codes,omitempty"`
	AppIds               []string   `protobuf:"bytes,3,rep,name=app_ids,json=appIds,proto3" json:"app_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ActiveOnRangeRequest) Reset()         { *m = ActiveOnRangeRequest{} }
func (m *ActiveOnRangeRequest) String() string { return proto.CompactTextString(m) }
func (*ActiveOnRangeRequest) ProtoMessage()    {}
func (*ActiveOnRangeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{18}
}
func (m *ActiveOnRangeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ActiveOnRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ActiveOnRangeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ActiveOnRangeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ActiveOnRangeRequest.Merge(m, src)
}
func (m *ActiveOnRangeRequest) XXX_Size() int {
	return m.Size()
}
func (m *ActiveOnRangeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ActiveOnRangeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ActiveOnRangeRequest proto.InternalMessageInfo

func (m *ActiveOnRangeRequest) GetRange() *TimeRange {
	if m != nil {
		return m.Range
	}
	return nil
}

func (m *ActiveOnRangeRequest) GetCountryCodes() []string {
	if m != nil {
		return m.CountryCodes
	}
	return nil
}

func (m *ActiveOnRangeRequest) GetAppIds() []string {
	if m != nil {
		return m.AppIds
	}
	return nil
}

type GameInfoResponse struct {
	GameId               string                        `protobuf:"bytes,1,opt,name=game_id,json=gameId,proto3" json:"game_id,omitempty"`
	Events               []*GameInfoResponse_EventInfo `protobuf:"bytes,2,rep,name=events,proto3" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *GameInfoResponse) Reset()         { *m = GameInfoResponse{} }
func (m *GameInfoResponse) String() string { return proto.CompactTextString(m) }
func (*GameInfoResponse) ProtoMessage()    {}
func (*GameInfoResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{19}
}
func (m *GameInfoResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GameInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GameInfoResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GameInfoResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GameInfoResponse.Merge(m, src)
}
func (m *GameInfoResponse) XXX_Size() int {
	return m.Size()
}
func (m *GameInfoResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GameInfoResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GameInfoResponse proto.InternalMessageInfo

func (m *GameInfoResponse) GetGameId() string {
	if m != nil {
		return m.GameId
	}
	return ""
}

func (m *GameInfoResponse) GetEvents() []*GameInfoResponse_EventInfo {
	if m != nil {
		return m.Events
	}
	return nil
}

type GameInfoResponse_FieldInfo struct {
	Name                 string                     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type                 GameInfoResponse_FieldType `protobuf:"varint,2,opt,name=type,proto3,enum=apipb.GameInfoResponse_FieldType" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *GameInfoResponse_FieldInfo) Reset()         { *m = GameInfoResponse_FieldInfo{} }
func (m *GameInfoResponse_FieldInfo) String() string { return proto.CompactTextString(m) }
func (*GameInfoResponse_FieldInfo) ProtoMessage()    {}
func (*GameInfoResponse_FieldInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{19, 0}
}
func (m *GameInfoResponse_FieldInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GameInfoResponse_FieldInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GameInfoResponse_FieldInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GameInfoResponse_FieldInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GameInfoResponse_FieldInfo.Merge(m, src)
}
func (m *GameInfoResponse_FieldInfo) XXX_Size() int {
	return m.Size()
}
func (m *GameInfoResponse_FieldInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_GameInfoResponse_FieldInfo.DiscardUnknown(m)
}

var xxx_messageInfo_GameInfoResponse_FieldInfo proto.InternalMessageInfo

func (m *GameInfoResponse_FieldInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *GameInfoResponse_FieldInfo) GetType() GameInfoResponse_FieldType {
	if m != nil {
		return m.Type
	}
	return GameInfoResponse_UNKNOWN
}

type GameInfoResponse_EventInfo struct {
	Name                 string                        `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Fields               []*GameInfoResponse_FieldInfo `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *GameInfoResponse_EventInfo) Reset()         { *m = GameInfoResponse_EventInfo{} }
func (m *GameInfoResponse_EventInfo) String() string { return proto.CompactTextString(m) }
func (*GameInfoResponse_EventInfo) ProtoMessage()    {}
func (*GameInfoResponse_EventInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{19, 1}
}
func (m *GameInfoResponse_EventInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GameInfoResponse_EventInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GameInfoResponse_EventInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GameInfoResponse_EventInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GameInfoResponse_EventInfo.Merge(m, src)
}
func (m *GameInfoResponse_EventInfo) XXX_Size() int {
	return m.Size()
}
func (m *GameInfoResponse_EventInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_GameInfoResponse_EventInfo.DiscardUnknown(m)
}

var xxx_messageInfo_GameInfoResponse_EventInfo proto.InternalMessageInfo

func (m *GameInfoResponse_EventInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *GameInfoResponse_EventInfo) GetFields() []*GameInfoResponse_FieldInfo {
	if m != nil {
		return m.Fields
	}
	return nil
}

type AppDataInfoReq struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AppDataInfoReq) Reset()         { *m = AppDataInfoReq{} }
func (m *AppDataInfoReq) String() string { return proto.CompactTextString(m) }
func (*AppDataInfoReq) ProtoMessage()    {}
func (*AppDataInfoReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1f40f047c7fd56f, []int{20}
}
func (m *AppDataInfoReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppDataInfoReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AppDataInfoReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AppDataInfoReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppDataInfoReq.Merge(m, src)
}
func (m *AppDataInfoReq) XXX_Size() int {
	return m.Size()
}
func (m *AppDataInfoReq) XXX_DiscardUnknown() {
	xxx_messageInfo_AppDataInfoReq.DiscardUnknown(m)
}

var xxx_messageInfo_AppDataInfoReq proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("apipb.QuerySort_SortOrder", QuerySort_SortOrder_name, QuerySort_SortOrder_value)
	proto.RegisterEnum("apipb.Aggregation_Accumulator", Aggregation_Accumulator_name, Aggregation_Accumulator_value)
	proto.RegisterEnum("apipb.QueryGroup_GroupType", QueryGroup_GroupType_name, QueryGroup_GroupType_value)
	proto.RegisterEnum("apipb.ActiveUsersRequest_Type", ActiveUsersRequest_Type_name, ActiveUsersRequest_Type_value)
	proto.RegisterEnum("apipb.RetentionRequest_Type", RetentionRequest_Type_name, RetentionRequest_Type_value)
	proto.RegisterEnum("apipb.GameInfoResponse_FieldType", GameInfoResponse_FieldType_name, GameInfoResponse_FieldType_value)
	proto.RegisterType((*TimeRange)(nil), "apipb.TimeRange")
	proto.RegisterType((*ChildAndProfileIds)(nil), "apipb.ChildAndProfileIds")
	proto.RegisterType((*ChildAndTimeRange)(nil), "apipb.ChildAndTimeRange")
	proto.RegisterType((*GameWithVersions)(nil), "apipb.GameWithVersions")
	proto.RegisterType((*PlayedGamesList)(nil), "apipb.PlayedGamesList")
	proto.RegisterType((*QuerySort)(nil), "apipb.QuerySort")
	proto.RegisterType((*Aggregation)(nil), "apipb.Aggregation")
	proto.RegisterType((*GroupInterval)(nil), "apipb.GroupInterval")
	proto.RegisterType((*QueryGroup)(nil), "apipb.QueryGroup")
	proto.RegisterType((*Query)(nil), "apipb.Query")
	proto.RegisterType((*AnalyzeRequest)(nil), "apipb.AnalyzeRequest")
	proto.RegisterType((*AnalyzeResult)(nil), "apipb.AnalyzeResult")
	proto.RegisterType((*ActiveUsersRequest)(nil), "apipb.ActiveUsersRequest")
	proto.RegisterType((*ActiveUsersResult)(nil), "apipb.ActiveUsersResult")
	proto.RegisterType((*RetentionRequest)(nil), "apipb.RetentionRequest")
	proto.RegisterType((*RetentionResult)(nil), "apipb.RetentionResult")
	proto.RegisterType((*InactiveUsersRequest)(nil), "apipb.InactiveUsersRequest")
	proto.RegisterType((*GetActiveUsersRequest)(nil), "apipb.GetActiveUsersRequest")
	proto.RegisterType((*ActiveOnRangeRequest)(nil), "apipb.ActiveOnRangeRequest")
	proto.RegisterType((*GameInfoResponse)(nil), "apipb.GameInfoResponse")
	proto.RegisterType((*GameInfoResponse_FieldInfo)(nil), "apipb.GameInfoResponse.FieldInfo")
	proto.RegisterType((*GameInfoResponse_EventInfo)(nil), "apipb.GameInfoResponse.EventInfo")
	proto.RegisterType((*AppDataInfoReq)(nil), "apipb.AppDataInfoReq")
}

func init() { proto.RegisterFile("analysis.proto", fileDescriptor_f1f40f047c7fd56f) }

var fileDescriptor_f1f40f047c7fd56f = []byte{
	// 1570 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcb, 0x6e, 0xdb, 0xcc,
	0x15, 0x36, 0xa9, 0x2b, 0x8f, 0x64, 0x99, 0x9e, 0xda, 0xb1, 0xa2, 0x34, 0xae, 0xc3, 0x16, 0x81,
	0x0b, 0x34, 0x8a, 0xa3, 0x20, 0x01, 0x02, 0xa4, 0x68, 0x65, 0xcb, 0x71, 0x85, 0xda, 0x92, 0x33,
	0x92, 0xed, 0x24, 0x1b, 0x61, 0x2c, 0x8e, 0x15, 0x02, 0x12, 0xc9, 0x70, 0x86, 0x0e, 0x94, 0x76,
	0xd7, 0x45, 0x17, 0x5d, 0x76, 0xd3, 0xae, 0x0a, 0x74, 0xd5, 0x17, 0xe8, 0xba, 0xdb, 0x2e, 0xfb,
	0x06, 0x2d, 0xdc, 0x57, 0xf8, 0x1f, 0xe0, 0xc7, 0x0c, 0x87, 0xd4, 0xc5, 0x96, 0x13, 0xe4, 0xcf,
	0x86, 0x98, 0x73, 0x99, 0x33, 0xe7, 0x3b, 0x73, 0x2e, 0x43, 0x28, 0x11, 0x97, 0x0c, 0xc7, 0xcc,
	0x61, 0x55, 0x3f, 0xf0, 0xb8, 0x87, 0x32, 0xc4, 0x77, 0xfc, 0xf3, 0xca, 0x8f, 0x6c, 0xc2, 0x09,
	0xa3, 0x7c, 0xe4, 0xd9, 0x74, 0xa8, 0x64, 0xd6, 0x63, 0x30, 0xba, 0xce, 0x88, 0x62, 0xe2, 0x0e,
	0x28, 0x42, 0x90, 0xbe, 0x08, 0xbc, 0x51, 0x59, 0xdb, 0xd2, 0xb6, 0x53, 0x58, 0xae, 0x51, 0x09,
	0x74, 0xee, 0x95, 0x75, 0xc9, 0xd1, 0xb9, 0x67, 0xb5, 0x00, 0xed, 0xbd, 0x77, 0x86, 0x76, 0xdd,
	0xb5, 0x8f, 0x03, 0xef, 0xc2, 0x19, 0xd2, 0xa6, 0xcd, 0xd0, 0x5d, 0xc8, 0xf7, 0x05, 0xb7, 0xe7,
	0xd8, 0x72, 0xb7, 0x81, 0x73, 0x92, 0x6e, 0xda, 0xe8, 0x3e, 0x80, 0x1f, 0x29, 0x0a, 0xa1, 0x2e,
	0x85, 0x86, 0x1f, 0x6f, 0xb5, 0x42, 0x58, 0x8d, 0xed, 0x4d, 0x1c, 0xf9, 0x6a, 0x73, 0xe8, 0x21,
	0x64, 0x02, 0x61, 0xa2, 0x9c, 0xda, 0xd2, 0xb6, 0x0b, 0x35, 0xb3, 0x2a, 0xb1, 0x57, 0x13, 0xd3,
	0x38, 0x12, 0x5b, 0x07, 0x60, 0x1e, 0x90, 0x11, 0x3d, 0x73, 0xf8, 0xfb, 0x53, 0x1a, 0x30, 0xc7,
	0x73, 0x19, 0xda, 0x80, 0xdc, 0x80, 0x8c, 0xe8, 0xe4, 0xd0, 0xac, 0x20, 0x9b, 0x36, 0xaa, 0x40,
	0xfe, 0x52, 0x29, 0x95, 0xf5, 0xad, 0xd4, 0xb6, 0x81, 0x13, 0xda, 0xfa, 0x83, 0x06, 0x2b, 0xc7,
	0x43, 0x32, 0xa6, 0xb6, 0xb0, 0xc7, 0x0e, 0x1d, 0xc6, 0xd1, 0x23, 0xc8, 0x88, 0x9d, 0xac, 0xac,
	0x6d, 0xa5, 0xb6, 0x0b, 0xb5, 0x0d, 0xe5, 0xc4, 0xfc, 0x81, 0x38, 0xd2, 0x9a, 0x41, 0xab, 0xcf,
	0xa2, 0xfd, 0x52, 0x38, 0xbf, 0x03, 0xe3, 0x75, 0x48, 0x83, 0x71, 0xc7, 0x0b, 0xb8, 0x08, 0xd1,
	0x85, 0x43, 0x87, 0x76, 0xcf, 0x25, 0x23, 0xaa, 0xa0, 0x18, 0x92, 0xd3, 0x22, 0x23, 0x8a, 0x76,
	0x20, 0xe3, 0x05, 0x36, 0x0d, 0xe4, 0x59, 0xa5, 0x5a, 0x45, 0xd9, 0x4c, 0xf6, 0x57, 0xc5, 0xa7,
	0x2d, 0x34, 0x70, 0xa4, 0x68, 0xdd, 0x07, 0x23, 0xe1, 0xa1, 0x1c, 0xa4, 0xea, 0x9d, 0x3d, 0x73,
	0x49, 0x2c, 0x1a, 0x9d, 0x3d, 0x53, 0xb3, 0xbe, 0xd3, 0xa0, 0x50, 0x1f, 0x0c, 0x02, 0x3a, 0x20,
	0xdc, 0xf1, 0xdc, 0xcf, 0x9d, 0xff, 0x00, 0x8a, 0x5e, 0xc8, 0xfd, 0x90, 0xf7, 0x24, 0x4f, 0x41,
	0x2e, 0x44, 0xbc, 0x57, 0x82, 0x85, 0x7e, 0x0d, 0x05, 0xd2, 0xef, 0x87, 0xa3, 0x70, 0x48, 0xb8,
	0x17, 0x48, 0xf0, 0xa5, 0xda, 0xa6, 0x72, 0x74, 0xea, 0xa8, 0x6a, 0x7d, 0xa2, 0x85, 0xa7, 0xb7,
	0x58, 0x04, 0x0a, 0x53, 0x32, 0x94, 0x87, 0x74, 0xab, 0xdd, 0xda, 0x37, 0x97, 0x90, 0x01, 0x99,
	0xbd, 0xf6, 0x49, 0xab, 0x6b, 0x6a, 0x02, 0x40, 0xe7, 0xe4, 0xc8, 0xd4, 0xc5, 0xe2, 0xa8, 0xfe,
	0xc6, 0x4c, 0xc9, 0x45, 0xb3, 0x65, 0xa6, 0x25, 0xc8, 0xd3, 0x03, 0x33, 0x83, 0x8a, 0x90, 0xef,
	0x74, 0x1b, 0xbd, 0x4e, 0xfd, 0xe8, 0xd8, 0xcc, 0xa2, 0x02, 0xe4, 0x04, 0x75, 0xdc, 0x3e, 0x36,
	0x73, 0xd6, 0x9f, 0x35, 0x58, 0x3e, 0x08, 0xbc, 0xd0, 0x6f, 0xba, 0x9c, 0x06, 0x97, 0x64, 0x88,
	0x4c, 0x48, 0x39, 0x2e, 0x97, 0x88, 0x33, 0x58, 0x2c, 0x45, 0x45, 0x05, 0x94, 0x0c, 0x25, 0x46,
	0x1d, 0xcb, 0xb5, 0xe0, 0xd9, 0x64, 0xcc, 0x24, 0xaa, 0x0c, 0x96, 0x6b, 0xb4, 0x06, 0x99, 0xf7,
	0x5e, 0x18, 0xb0, 0x72, 0x5a, 0x32, 0x23, 0x02, 0x95, 0x21, 0x37, 0x72, 0xdc, 0x90, 0x53, 0x56,
	0xce, 0x6c, 0x69, 0xdb, 0x79, 0x1c, 0x93, 0x42, 0xc2, 0x68, 0xdf, 0x73, 0x6d, 0x56, 0xce, 0x46,
	0x12, 0x45, 0x5a, 0xff, 0xd4, 0x01, 0xe4, 0x55, 0x4a, 0xd7, 0x3e, 0x77, 0x17, 0x8f, 0x21, 0xcd,
	0xc7, 0x3e, 0x55, 0xa9, 0x70, 0x6f, 0x3a, 0x15, 0xe4, 0xfe, 0xaa, 0xfc, 0x76, 0xc7, 0x3e, 0xc5,
	0x52, 0x11, 0xed, 0x40, 0xde, 0x51, 0x70, 0x55, 0x4e, 0xae, 0xc5, 0xd9, 0x3d, 0x1d, 0x0a, 0x9c,
	0x68, 0x5d, 0xbb, 0xee, 0xf4, 0xf5, 0xeb, 0xfe, 0x39, 0x98, 0xdc, 0x19, 0xd1, 0x4f, 0x9e, 0x4b,
	0x7b, 0x31, 0xac, 0x8c, 0x0c, 0xc4, 0x4a, 0xcc, 0xef, 0x28, 0x78, 0x67, 0x60, 0x24, 0x2e, 0x89,
	0x5b, 0x6d, 0x10, 0x4e, 0xcd, 0x25, 0x71, 0x4d, 0x62, 0x25, 0xb4, 0x4d, 0x0d, 0x2d, 0x47, 0x4d,
	0xad, 0x7d, 0xd1, 0x20, 0x63, 0x53, 0x97, 0x42, 0x87, 0xf5, 0x03, 0xca, 0xa9, 0x99, 0x42, 0xeb,
	0xb0, 0xba, 0xe7, 0xb9, 0xdc, 0x71, 0x43, 0xca, 0x62, 0x77, 0xcd, 0xb4, 0xf5, 0x77, 0x1d, 0x32,
	0x12, 0x37, 0xba, 0x03, 0x59, 0x7a, 0x49, 0x5d, 0x1e, 0x95, 0xaf, 0x81, 0x15, 0x35, 0xa9, 0x45,
	0xfd, 0xd6, 0x5a, 0x44, 0x3f, 0x83, 0x34, 0xf3, 0x02, 0x5e, 0x4e, 0xc9, 0xe2, 0x37, 0xe7, 0xcb,
	0x0b, 0x4b, 0xa9, 0xb8, 0xf1, 0xa1, 0x33, 0x72, 0x78, 0x7c, 0xe3, 0x92, 0x10, 0x67, 0x7b, 0x17,
	0x17, 0x8c, 0x72, 0x85, 0x5f, 0x51, 0xe8, 0x17, 0x90, 0x1f, 0x08, 0xd8, 0xbd, 0xf3, 0xb1, 0xbc,
	0xf0, 0x42, 0x6d, 0xf5, 0xda, 0x5d, 0xe1, 0x9c, 0x54, 0xd9, 0x1d, 0xa3, 0xe7, 0x50, 0x24, 0x93,
	0x22, 0x61, 0xe5, 0x9c, 0xf4, 0x04, 0x5d, 0xaf, 0x1f, 0x3c, 0xa3, 0x87, 0x7e, 0x02, 0x85, 0x80,
	0x7c, 0xec, 0x7d, 0x08, 0x69, 0xe0, 0x50, 0x56, 0xce, 0x6f, 0xa5, 0xb6, 0x8b, 0x18, 0x02, 0xf2,
	0xf1, 0x75, 0xc4, 0xb1, 0xfe, 0xa5, 0x41, 0xa9, 0x2e, 0x86, 0xcb, 0x27, 0x8a, 0xe9, 0x87, 0x90,
	0x32, 0xfe, 0x03, 0x5a, 0xf5, 0x16, 0x14, 0x43, 0x46, 0x7b, 0xc4, 0xf7, 0x7b, 0x62, 0x32, 0xc9,
	0x74, 0xca, 0x63, 0x08, 0x19, 0xad, 0xfb, 0x7e, 0x83, 0x70, 0x82, 0x2c, 0xc8, 0x08, 0x5f, 0x62,
	0xc8, 0xc5, 0x69, 0xc8, 0x38, 0x12, 0x4d, 0x7a, 0x6d, 0xee, 0x4b, 0x7a, 0xad, 0x68, 0xd7, 0xcb,
	0x09, 0x02, 0x16, 0x0e, 0x39, 0x7a, 0x0c, 0xb9, 0x20, 0xc2, 0x22, 0xfd, 0x2f, 0xd4, 0xd6, 0xe3,
	0x38, 0xcd, 0x00, 0xc5, 0xb1, 0x16, 0xb2, 0x44, 0xfd, 0x72, 0xa2, 0xd2, 0xa0, 0xa4, 0xb4, 0x85,
	0xc3, 0x1d, 0xca, 0xb1, 0x94, 0x09, 0xe8, 0xfd, 0x80, 0x12, 0x4e, 0xed, 0x1e, 0xe1, 0x12, 0x59,
	0x0a, 0x1b, 0x8a, 0x53, 0xe7, 0xd6, 0x3f, 0x34, 0x40, 0xf5, 0x3e, 0x77, 0x2e, 0xe9, 0x09, 0xa3,
	0x01, 0x8b, 0x63, 0x59, 0x53, 0xd5, 0xa8, 0xcd, 0xf6, 0xbb, 0x6b, 0x8a, 0xd5, 0xa9, 0x82, 0x5c,
	0x83, 0x8c, 0x4d, 0x44, 0x87, 0x10, 0x83, 0x29, 0x85, 0x23, 0x02, 0xad, 0x43, 0x56, 0xc4, 0xd5,
	0xb1, 0xe5, 0xd9, 0x06, 0xce, 0x10, 0xdf, 0x6f, 0xda, 0xd6, 0x13, 0x48, 0xcb, 0xc2, 0x01, 0xc8,
	0x1e, 0xb5, 0x5b, 0xdd, 0xc3, 0xb7, 0x51, 0x43, 0x6c, 0xd4, 0x9b, 0x87, 0x6f, 0xa3, 0x86, 0xd8,
	0xda, 0x3f, 0x33, 0x75, 0xc1, 0xeb, 0xb6, 0xbb, 0xf5, 0x43, 0x33, 0x65, 0xfd, 0x49, 0x83, 0xd5,
	0x19, 0x0f, 0x64, 0xd0, 0x9e, 0xce, 0x07, 0xed, 0xee, 0x42, 0x67, 0xbf, 0x69, 0xe0, 0xfe, 0xaa,
	0x81, 0x89, 0x29, 0xa7, 0xae, 0xcc, 0x5e, 0x65, 0x77, 0x67, 0x26, 0x6c, 0x3f, 0x56, 0x76, 0xe7,
	0xd5, 0xbe, 0x3a, 0x68, 0x0f, 0x55, 0xd0, 0x72, 0x90, 0x4a, 0x46, 0x48, 0x67, 0xff, 0x74, 0xbf,
	0x65, 0x6a, 0x22, 0x90, 0xdd, 0xdf, 0x34, 0x71, 0xf7, 0xad, 0xa9, 0x5b, 0x7f, 0xd4, 0x60, 0x65,
	0xea, 0x50, 0x19, 0xa7, 0x27, 0xf3, 0x71, 0xda, 0x58, 0xe0, 0xdd, 0x37, 0x8d, 0xd2, 0xdf, 0x34,
	0x58, 0x6b, 0xba, 0xe4, 0x7a, 0x82, 0x4d, 0x10, 0x6a, 0x53, 0x08, 0xd1, 0x0b, 0x58, 0x71, 0x94,
	0x7a, 0xcf, 0x0e, 0x03, 0xc7, 0x1d, 0x2c, 0xec, 0x71, 0xa5, 0x58, 0xb1, 0x21, 0xf5, 0xd0, 0x33,
	0x58, 0x9e, 0xdd, 0xb8, 0xe8, 0xa1, 0x52, 0x9c, 0xde, 0x66, 0xbd, 0x81, 0xf5, 0x03, 0xca, 0xeb,
	0x5f, 0xec, 0xe1, 0x36, 0x64, 0x7d, 0x1a, 0x38, 0x9e, 0xbd, 0xd0, 0x31, 0x25, 0xb7, 0x7e, 0x0f,
	0x6b, 0x91, 0xd9, 0xb6, 0x1b, 0x09, 0x94, 0xe1, 0xa4, 0x7b, 0x6b, 0xb7, 0x77, 0xef, 0x9f, 0xc2,
	0x72, 0xdf, 0x0b, 0x5d, 0x1e, 0x8c, 0x7b, 0x7d, 0xcf, 0xa6, 0xf1, 0x83, 0xaf, 0xa8, 0x98, 0x7b,
	0x82, 0x27, 0x5e, 0x8a, 0x91, 0x97, 0x4c, 0x76, 0x79, 0x03, 0x67, 0xa5, 0x9b, 0xcc, 0xba, 0xd2,
	0xa3, 0x77, 0x65, 0xd3, 0xbd, 0xf0, 0x30, 0x65, 0xbe, 0xe7, 0x32, 0xba, 0xf8, 0x5d, 0xf9, 0x22,
	0x99, 0x34, 0xba, 0x6c, 0x5e, 0x0f, 0xa6, 0x9a, 0xd7, 0xb4, 0x85, 0xea, 0xbe, 0xd0, 0x92, 0x1c,
	0xb5, 0xa1, 0x72, 0x0a, 0x86, 0x9c, 0x9d, 0x82, 0x29, 0x5e, 0x14, 0x53, 0xe3, 0x5d, 0xae, 0xd1,
	0xb3, 0x99, 0xc9, 0xbe, 0xd0, 0xb2, 0x34, 0x32, 0xa9, 0x8c, 0xca, 0x3b, 0x30, 0x92, 0xc3, 0x6e,
	0xb4, 0xfb, 0x02, 0xb2, 0x72, 0x8e, 0x7f, 0xd6, 0xe7, 0xc4, 0x3d, 0xac, 0x36, 0x58, 0xaf, 0x94,
	0xcf, 0xb2, 0x9a, 0x0a, 0x90, 0x3b, 0x69, 0xfd, 0xb6, 0xd5, 0x3e, 0x6b, 0x99, 0x4b, 0xa2, 0x8c,
	0x3a, 0x5d, 0xdc, 0x6c, 0x1d, 0x98, 0x9a, 0x10, 0x34, 0x5b, 0xdd, 0xfd, 0x83, 0x7d, 0x1c, 0x35,
	0xa2, 0x57, 0x87, 0xed, 0x7a, 0xd7, 0x4c, 0x89, 0x61, 0xbf, 0xdb, 0x6e, 0x1f, 0x9a, 0x69, 0xcb,
	0x84, 0x92, 0x9a, 0x10, 0xd1, 0x81, 0x1f, 0x6a, 0xff, 0x4d, 0xc3, 0x4a, 0x5d, 0xfd, 0xf4, 0x74,
	0x68, 0x70, 0xe9, 0xf4, 0x29, 0x6a, 0xc2, 0xf2, 0x4c, 0x22, 0xa0, 0x7b, 0x33, 0x2d, 0x6a, 0x36,
	0x3d, 0x2a, 0x71, 0xff, 0xba, 0xfe, 0x6f, 0xb3, 0xa3, 0xa1, 0x06, 0xe4, 0xe3, 0x72, 0x4a, 0xac,
	0xdc, 0x54, 0x5f, 0xb7, 0x5b, 0xd9, 0x83, 0x6c, 0x74, 0x34, 0x8a, 0x5b, 0xd4, 0x8d, 0x25, 0x70,
	0xbb, 0x91, 0x5f, 0x41, 0x61, 0xea, 0x6f, 0x03, 0x95, 0xe7, 0x74, 0x93, 0x74, 0xae, 0xdc, 0x51,
	0x92, 0xf9, 0x7f, 0x93, 0xe7, 0x90, 0x53, 0x83, 0x0d, 0xdd, 0x3c, 0xe8, 0x2a, 0x6b, 0xf3, 0x6c,
	0xd9, 0xc9, 0x76, 0xc5, 0x83, 0x3a, 0xf1, 0x15, 0x2d, 0xee, 0xf7, 0x95, 0xf2, 0x4d, 0x22, 0x69,
	0xe3, 0x25, 0x18, 0x49, 0xdf, 0x43, 0x8b, 0x3a, 0x61, 0xe2, 0xf9, 0x7c, 0x2f, 0x7d, 0x09, 0xf9,
	0x38, 0xc9, 0xd0, 0xa2, 0x31, 0x5f, 0xd9, 0x58, 0x90, 0x8e, 0xe8, 0x97, 0x50, 0x98, 0x4a, 0x9a,
	0x09, 0xf6, 0x99, 0x44, 0x5a, 0xb8, 0x7d, 0xf7, 0xd1, 0xbf, 0xaf, 0x36, 0xb5, 0xff, 0x5c, 0x6d,
	0x6a, 0xff, 0xbb, 0xda, 0xd4, 0xfe, 0xf2, 0xff, 0xcd, 0x25, 0x58, 0xe9, 0x7b, 0xa3, 0xaa, 0xc7,
	0x99, 0x33, 0xf2, 0xaa, 0x83, 0xc0, 0xef, 0x1f, 0x6b, 0xef, 0xf2, 0x11, 0xe9, 0x9f, 0x9f, 0x67,
	0xe5, 0xdf, 0xf5, 0xd3, 0xef, 0x03, 0x00, 0x00, 0xff, 0xff, 0x88, 0xbe, 0xc4, 0x1f, 0x8b, 0x0f,
	0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// AnalysisServiceClient is the client API for AnalysisService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AnalysisServiceClient interface {
	// ActiveOnRange returns child ids who active given time range
	ActiveOnRange(ctx context.Context, in *ActiveOnRangeRequest, opts ...grpc.CallOption) (AnalysisService_ActiveOnRangeClient, error)
	// Inactive calculates inactive users who was active given period but not
	// after at given app
	Inactive(ctx context.Context, in *InactiveUsersRequest, opts ...grpc.CallOption) (AnalysisService_InactiveClient, error)
	// Active streams active user on given period
	Active(ctx context.Context, in *GetActiveUsersRequest, opts ...grpc.CallOption) (AnalysisService_ActiveClient, error)
	// PlayedGames returns games played during given time range
	PlayedGames(ctx context.Context, in *ChildAndTimeRange, opts ...grpc.CallOption) (*PlayedGamesList, error)
	// Analyze calculates given request
	Analyze(ctx context.Context, in *AnalyzeRequest, opts ...grpc.CallOption) (*AnalyzeResult, error)
	// ActiveUsers calculates MAU, DAU
	ActiveUsers(ctx context.Context, in *ActiveUsersRequest, opts ...grpc.CallOption) (*ActiveUsersResult, error)
	// Retention returns retentation
	Retention(ctx context.Context, in *RetentionRequest, opts ...grpc.CallOption) (*RetentionResult, error)
	// GameInfo returns available events of a game
	GameInfo(ctx context.Context, in *GameWithVersions, opts ...grpc.CallOption) (*GameInfoResponse, error)
	// AppDataInfo returns available events and their fields
	AppDataInfo(ctx context.Context, in *AppDataInfoReq, opts ...grpc.CallOption) (*GameInfoResponse, error)
}

type analysisServiceClient struct {
	cc *grpc.ClientConn
}

func NewAnalysisServiceClient(cc *grpc.ClientConn) AnalysisServiceClient {
	return &analysisServiceClient{cc}
}

func (c *analysisServiceClient) ActiveOnRange(ctx context.Context, in *ActiveOnRangeRequest, opts ...grpc.CallOption) (AnalysisService_ActiveOnRangeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AnalysisService_serviceDesc.Streams[0], "/apipb.AnalysisService/ActiveOnRange", opts...)
	if err != nil {
		return nil, err
	}
	x := &analysisServiceActiveOnRangeClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AnalysisService_ActiveOnRangeClient interface {
	Recv() (*ChildAndProfileIds, error)
	grpc.ClientStream
}

type analysisServiceActiveOnRangeClient struct {
	grpc.ClientStream
}

func (x *analysisServiceActiveOnRangeClient) Recv() (*ChildAndProfileIds, error) {
	m := new(ChildAndProfileIds)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *analysisServiceClient) Inactive(ctx context.Context, in *InactiveUsersRequest, opts ...grpc.CallOption) (AnalysisService_InactiveClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AnalysisService_serviceDesc.Streams[1], "/apipb.AnalysisService/Inactive", opts...)
	if err != nil {
		return nil, err
	}
	x := &analysisServiceInactiveClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AnalysisService_InactiveClient interface {
	Recv() (*ChildAndProfileIds, error)
	grpc.ClientStream
}

type analysisServiceInactiveClient struct {
	grpc.ClientStream
}

func (x *analysisServiceInactiveClient) Recv() (*ChildAndProfileIds, error) {
	m := new(ChildAndProfileIds)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *analysisServiceClient) Active(ctx context.Context, in *GetActiveUsersRequest, opts ...grpc.CallOption) (AnalysisService_ActiveClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AnalysisService_serviceDesc.Streams[2], "/apipb.AnalysisService/Active", opts...)
	if err != nil {
		return nil, err
	}
	x := &analysisServiceActiveClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AnalysisService_ActiveClient interface {
	Recv() (*ChildAndProfileIds, error)
	grpc.ClientStream
}

type analysisServiceActiveClient struct {
	grpc.ClientStream
}

func (x *analysisServiceActiveClient) Recv() (*ChildAndProfileIds, error) {
	m := new(ChildAndProfileIds)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *analysisServiceClient) PlayedGames(ctx context.Context, in *ChildAndTimeRange, opts ...grpc.CallOption) (*PlayedGamesList, error) {
	out := new(PlayedGamesList)
	err := c.cc.Invoke(ctx, "/apipb.AnalysisService/PlayedGames", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisServiceClient) Analyze(ctx context.Context, in *AnalyzeRequest, opts ...grpc.CallOption) (*AnalyzeResult, error) {
	out := new(AnalyzeResult)
	err := c.cc.Invoke(ctx, "/apipb.AnalysisService/Analyze", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisServiceClient) ActiveUsers(ctx context.Context, in *ActiveUsersRequest, opts ...grpc.CallOption) (*ActiveUsersResult, error) {
	out := new(ActiveUsersResult)
	err := c.cc.Invoke(ctx, "/apipb.AnalysisService/ActiveUsers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisServiceClient) Retention(ctx context.Context, in *RetentionRequest, opts ...grpc.CallOption) (*RetentionResult, error) {
	out := new(RetentionResult)
	err := c.cc.Invoke(ctx, "/apipb.AnalysisService/Retention", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisServiceClient) GameInfo(ctx context.Context, in *GameWithVersions, opts ...grpc.CallOption) (*GameInfoResponse, error) {
	out := new(GameInfoResponse)
	err := c.cc.Invoke(ctx, "/apipb.AnalysisService/GameInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisServiceClient) AppDataInfo(ctx context.Context, in *AppDataInfoReq, opts ...grpc.CallOption) (*GameInfoResponse, error) {
	out := new(GameInfoResponse)
	err := c.cc.Invoke(ctx, "/apipb.AnalysisService/AppDataInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AnalysisServiceServer is the server API for AnalysisService service.
type AnalysisServiceServer interface {
	// ActiveOnRange returns child ids who active given time range
	ActiveOnRange(*ActiveOnRangeRequest, AnalysisService_ActiveOnRangeServer) error
	// Inactive calculates inactive users who was active given period but not
	// after at given app
	Inactive(*InactiveUsersRequest, AnalysisService_InactiveServer) error
	// Active streams active user on given period
	Active(*GetActiveUsersRequest, AnalysisService_ActiveServer) error
	// PlayedGames returns games played during given time range
	PlayedGames(context.Context, *ChildAndTimeRange) (*PlayedGamesList, error)
	// Analyze calculates given request
	Analyze(context.Context, *AnalyzeRequest) (*AnalyzeResult, error)
	// ActiveUsers calculates MAU, DAU
	ActiveUsers(context.Context, *ActiveUsersRequest) (*ActiveUsersResult, error)
	// Retention returns retentation
	Retention(context.Context, *RetentionRequest) (*RetentionResult, error)
	// GameInfo returns available events of a game
	GameInfo(context.Context, *GameWithVersions) (*GameInfoResponse, error)
	// AppDataInfo returns available events and their fields
	AppDataInfo(context.Context, *AppDataInfoReq) (*GameInfoResponse, error)
}

// UnimplementedAnalysisServiceServer can be embedded to have forward compatible implementations.
type UnimplementedAnalysisServiceServer struct {
}

func (*UnimplementedAnalysisServiceServer) ActiveOnRange(req *ActiveOnRangeRequest, srv AnalysisService_ActiveOnRangeServer) error {
	return status.Errorf(codes.Unimplemented, "method ActiveOnRange not implemented")
}
func (*UnimplementedAnalysisServiceServer) Inactive(req *InactiveUsersRequest, srv AnalysisService_InactiveServer) error {
	return status.Errorf(codes.Unimplemented, "method Inactive not implemented")
}
func (*UnimplementedAnalysisServiceServer) Active(req *GetActiveUsersRequest, srv AnalysisService_ActiveServer) error {
	return status.Errorf(codes.Unimplemented, "method Active not implemented")
}
func (*UnimplementedAnalysisServiceServer) PlayedGames(ctx context.Context, req *ChildAndTimeRange) (*PlayedGamesList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PlayedGames not implemented")
}
func (*UnimplementedAnalysisServiceServer) Analyze(ctx context.Context, req *AnalyzeRequest) (*AnalyzeResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Analyze not implemented")
}
func (*UnimplementedAnalysisServiceServer) ActiveUsers(ctx context.Context, req *ActiveUsersRequest) (*ActiveUsersResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ActiveUsers not implemented")
}
func (*UnimplementedAnalysisServiceServer) Retention(ctx context.Context, req *RetentionRequest) (*RetentionResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Retention not implemented")
}
func (*UnimplementedAnalysisServiceServer) GameInfo(ctx context.Context, req *GameWithVersions) (*GameInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GameInfo not implemented")
}
func (*UnimplementedAnalysisServiceServer) AppDataInfo(ctx context.Context, req *AppDataInfoReq) (*GameInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AppDataInfo not implemented")
}

func RegisterAnalysisServiceServer(s *grpc.Server, srv AnalysisServiceServer) {
	s.RegisterService(&_AnalysisService_serviceDesc, srv)
}

func _AnalysisService_ActiveOnRange_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ActiveOnRangeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AnalysisServiceServer).ActiveOnRange(m, &analysisServiceActiveOnRangeServer{stream})
}

type AnalysisService_ActiveOnRangeServer interface {
	Send(*ChildAndProfileIds) error
	grpc.ServerStream
}

type analysisServiceActiveOnRangeServer struct {
	grpc.ServerStream
}

func (x *analysisServiceActiveOnRangeServer) Send(m *ChildAndProfileIds) error {
	return x.ServerStream.SendMsg(m)
}

func _AnalysisService_Inactive_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InactiveUsersRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AnalysisServiceServer).Inactive(m, &analysisServiceInactiveServer{stream})
}

type AnalysisService_InactiveServer interface {
	Send(*ChildAndProfileIds) error
	grpc.ServerStream
}

type analysisServiceInactiveServer struct {
	grpc.ServerStream
}

func (x *analysisServiceInactiveServer) Send(m *ChildAndProfileIds) error {
	return x.ServerStream.SendMsg(m)
}

func _AnalysisService_Active_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetActiveUsersRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AnalysisServiceServer).Active(m, &analysisServiceActiveServer{stream})
}

type AnalysisService_ActiveServer interface {
	Send(*ChildAndProfileIds) error
	grpc.ServerStream
}

type analysisServiceActiveServer struct {
	grpc.ServerStream
}

func (x *analysisServiceActiveServer) Send(m *ChildAndProfileIds) error {
	return x.ServerStream.SendMsg(m)
}

func _AnalysisService_PlayedGames_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChildAndTimeRange)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServiceServer).PlayedGames(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apipb.AnalysisService/PlayedGames",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServiceServer).PlayedGames(ctx, req.(*ChildAndTimeRange))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisService_Analyze_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AnalyzeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServiceServer).Analyze(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apipb.AnalysisService/Analyze",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServiceServer).Analyze(ctx, req.(*AnalyzeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisService_ActiveUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ActiveUsersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServiceServer).ActiveUsers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apipb.AnalysisService/ActiveUsers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServiceServer).ActiveUsers(ctx, req.(*ActiveUsersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisService_Retention_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RetentionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServiceServer).Retention(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apipb.AnalysisService/Retention",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServiceServer).Retention(ctx, req.(*RetentionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisService_GameInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GameWithVersions)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServiceServer).GameInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apipb.AnalysisService/GameInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServiceServer).GameInfo(ctx, req.(*GameWithVersions))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisService_AppDataInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AppDataInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServiceServer).AppDataInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/apipb.AnalysisService/AppDataInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServiceServer).AppDataInfo(ctx, req.(*AppDataInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _AnalysisService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "apipb.AnalysisService",
	HandlerType: (*AnalysisServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PlayedGames",
			Handler:    _AnalysisService_PlayedGames_Handler,
		},
		{
			MethodName: "Analyze",
			Handler:    _AnalysisService_Analyze_Handler,
		},
		{
			MethodName: "ActiveUsers",
			Handler:    _AnalysisService_ActiveUsers_Handler,
		},
		{
			MethodName: "Retention",
			Handler:    _AnalysisService_Retention_Handler,
		},
		{
			MethodName: "GameInfo",
			Handler:    _AnalysisService_GameInfo_Handler,
		},
		{
			MethodName: "AppDataInfo",
			Handler:    _AnalysisService_AppDataInfo_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ActiveOnRange",
			Handler:       _AnalysisService_ActiveOnRange_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Inactive",
			Handler:       _AnalysisService_Inactive_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Active",
			Handler:       _AnalysisService_Active_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "analysis.proto",
}

func (m *TimeRange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TimeRange) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.From != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.From))
	}
	if m.To != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.To))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ChildAndProfileIds) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ChildAndProfileIds) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ChildId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.ChildId)))
		i += copy(dAtA[i:], m.ChildId)
	}
	if len(m.ProfileId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.ProfileId)))
		i += copy(dAtA[i:], m.ProfileId)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ChildAndTimeRange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ChildAndTimeRange) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ChildId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.ChildId)))
		i += copy(dAtA[i:], m.ChildId)
	}
	if len(m.ProfileId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.ProfileId)))
		i += copy(dAtA[i:], m.ProfileId)
	}
	if m.Range != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Range.Size()))
		n1, err1 := m.Range.MarshalTo(dAtA[i:])
		if err1 != nil {
			return 0, err1
		}
		i += n1
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GameWithVersions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GameWithVersions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.GameId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.GameId)))
		i += copy(dAtA[i:], m.GameId)
	}
	if len(m.Versions) > 0 {
		for _, s := range m.Versions {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *PlayedGamesList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PlayedGamesList) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Games) > 0 {
		for _, msg := range m.Games {
			dAtA[i] = 0xa
			i++
			i = encodeVarintAnalysis(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.ChildId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.ChildId)))
		i += copy(dAtA[i:], m.ChildId)
	}
	if m.Range != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Range.Size()))
		n2, err2 := m.Range.MarshalTo(dAtA[i:])
		if err2 != nil {
			return 0, err2
		}
		i += n2
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *QuerySort) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QuerySort) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.FieldName) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.FieldName)))
		i += copy(dAtA[i:], m.FieldName)
	}
	if m.Order != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Order))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Aggregation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Aggregation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.FieldName) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.FieldName)))
		i += copy(dAtA[i:], m.FieldName)
	}
	if len(m.OutputField) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.OutputField)))
		i += copy(dAtA[i:], m.OutputField)
	}
	if m.Accumulator != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Accumulator))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GroupInterval) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GroupInterval) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Int != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Int))
	}
	if m.Real != 0 {
		dAtA[i] = 0x15
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Real))))
		i += 4
	}
	if m.Days != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Days))
	}
	if m.Hours != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Hours))
	}
	if m.Minutes {
		dAtA[i] = 0x28
		i++
		if m.Minutes {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Seconds {
		dAtA[i] = 0x30
		i++
		if m.Seconds {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *QueryGroup) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryGroup) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.FieldName) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.FieldName)))
		i += copy(dAtA[i:], m.FieldName)
	}
	if m.Type != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Type))
	}
	if m.Interval != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Interval.Size()))
		n3, err3 := m.Interval.MarshalTo(dAtA[i:])
		if err3 != nil {
			return 0, err3
		}
		i += n3
	}
	if len(m.OutputField) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.OutputField)))
		i += copy(dAtA[i:], m.OutputField)
	}
	if m.TimezoneSeconds != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.TimezoneSeconds))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Query) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Query) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Events) > 0 {
		for _, s := range m.Events {
			dAtA[i] = 0xa
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.Range != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Range.Size()))
		n4, err4 := m.Range.MarshalTo(dAtA[i:])
		if err4 != nil {
			return 0, err4
		}
		i += n4
	}
	if len(m.Sort) > 0 {
		for _, msg := range m.Sort {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintAnalysis(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Limit != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Limit))
	}
	if m.Offset != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Offset))
	}
	if m.GroupBy != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.GroupBy.Size()))
		n5, err5 := m.GroupBy.MarshalTo(dAtA[i:])
		if err5 != nil {
			return 0, err5
		}
		i += n5
	}
	if len(m.Aggregations) > 0 {
		for _, msg := range m.Aggregations {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintAnalysis(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.RawQueries) > 0 {
		for _, b := range m.RawQueries {
			dAtA[i] = 0x42
			i++
			i = encodeVarintAnalysis(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AnalyzeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AnalyzeRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ChildId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.ChildId)))
		i += copy(dAtA[i:], m.ChildId)
	}
	if len(m.ProfileId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.ProfileId)))
		i += copy(dAtA[i:], m.ProfileId)
	}
	if m.UseAppData {
		dAtA[i] = 0x18
		i++
		if m.UseAppData {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Query != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Query.Size()))
		n6, err6 := m.Query.MarshalTo(dAtA[i:])
		if err6 != nil {
			return 0, err6
		}
		i += n6
	}
	if len(m.Games) > 0 {
		for _, msg := range m.Games {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintAnalysis(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AnalyzeResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AnalyzeResult) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Request != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Request.Size()))
		n7, err7 := m.Request.MarshalTo(dAtA[i:])
		if err7 != nil {
			return 0, err7
		}
		i += n7
	}
	if m.Data != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Data.Size()))
		n8, err8 := m.Data.MarshalTo(dAtA[i:])
		if err8 != nil {
			return 0, err8
		}
		i += n8
	}
	if m.CreatedAt != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.CreatedAt))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ActiveUsersRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ActiveUsersRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Type))
	}
	if len(m.Dates) > 0 {
		dAtA10 := make([]byte, len(m.Dates)*10)
		var j9 int
		for _, num1 := range m.Dates {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j9++
			}
			dAtA10[j9] = uint8(num)
			j9++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(j9))
		i += copy(dAtA[i:], dAtA10[:j9])
	}
	if len(m.AppId) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.AppId)))
		i += copy(dAtA[i:], m.AppId)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ActiveUsersResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ActiveUsersResult) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Request != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Request.Size()))
		n11, err11 := m.Request.MarshalTo(dAtA[i:])
		if err11 != nil {
			return 0, err11
		}
		i += n11
	}
	if m.Data != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Data.Size()))
		n12, err12 := m.Data.MarshalTo(dAtA[i:])
		if err12 != nil {
			return 0, err12
		}
		i += n12
	}
	if m.CreatedAt != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.CreatedAt))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *RetentionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RetentionRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Type))
	}
	if len(m.Dates) > 0 {
		dAtA14 := make([]byte, len(m.Dates)*10)
		var j13 int
		for _, num1 := range m.Dates {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j13++
			}
			dAtA14[j13] = uint8(num)
			j13++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(j13))
		i += copy(dAtA[i:], dAtA14[:j13])
	}
	if len(m.AppId) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.AppId)))
		i += copy(dAtA[i:], m.AppId)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *RetentionResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RetentionResult) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Request != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Request.Size()))
		n15, err15 := m.Request.MarshalTo(dAtA[i:])
		if err15 != nil {
			return 0, err15
		}
		i += n15
	}
	if m.Data != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Data.Size()))
		n16, err16 := m.Data.MarshalTo(dAtA[i:])
		if err16 != nil {
			return 0, err16
		}
		i += n16
	}
	if m.CreatedAt != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.CreatedAt))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *InactiveUsersRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InactiveUsersRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.AppId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.AppId)))
		i += copy(dAtA[i:], m.AppId)
	}
	if m.InactiveDuring != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.InactiveDuring.Size()))
		n17, err17 := m.InactiveDuring.MarshalTo(dAtA[i:])
		if err17 != nil {
			return 0, err17
		}
		i += n17
	}
	if m.ActiveDuring != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.ActiveDuring.Size()))
		n18, err18 := m.ActiveDuring.MarshalTo(dAtA[i:])
		if err18 != nil {
			return 0, err18
		}
		i += n18
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetActiveUsersRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetActiveUsersRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.AppId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.AppId)))
		i += copy(dAtA[i:], m.AppId)
	}
	if m.Period != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Period.Size()))
		n19, err19 := m.Period.MarshalTo(dAtA[i:])
		if err19 != nil {
			return 0, err19
		}
		i += n19
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ActiveOnRangeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ActiveOnRangeRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Range != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Range.Size()))
		n20, err20 := m.Range.MarshalTo(dAtA[i:])
		if err20 != nil {
			return 0, err20
		}
		i += n20
	}
	if len(m.CountryCodes) > 0 {
		for _, s := range m.CountryCodes {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.AppIds) > 0 {
		for _, s := range m.AppIds {
			dAtA[i] = 0x1a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GameInfoResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GameInfoResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.GameId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.GameId)))
		i += copy(dAtA[i:], m.GameId)
	}
	if len(m.Events) > 0 {
		for _, msg := range m.Events {
			dAtA[i] = 0x12
			i++
			i = encodeVarintAnalysis(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GameInfoResponse_FieldInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GameInfoResponse_FieldInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Type != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(m.Type))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GameInfoResponse_EventInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GameInfoResponse_EventInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAnalysis(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Fields) > 0 {
		for _, msg := range m.Fields {
			dAtA[i] = 0x12
			i++
			i = encodeVarintAnalysis(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AppDataInfoReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AppDataInfoReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintAnalysis(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *TimeRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.From != 0 {
		n += 1 + sovAnalysis(uint64(m.From))
	}
	if m.To != 0 {
		n += 1 + sovAnalysis(uint64(m.To))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChildAndProfileIds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChildId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	l = len(m.ProfileId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChildAndTimeRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChildId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	l = len(m.ProfileId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Range != nil {
		l = m.Range.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GameWithVersions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.GameId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if len(m.Versions) > 0 {
		for _, s := range m.Versions {
			l = len(s)
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PlayedGamesList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Games) > 0 {
		for _, e := range m.Games {
			l = e.Size()
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	l = len(m.ChildId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Range != nil {
		l = m.Range.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *QuerySort) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FieldName)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Order != 0 {
		n += 1 + sovAnalysis(uint64(m.Order))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Aggregation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FieldName)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	l = len(m.OutputField)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Accumulator != 0 {
		n += 1 + sovAnalysis(uint64(m.Accumulator))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GroupInterval) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Int != 0 {
		n += 1 + sovAnalysis(uint64(m.Int))
	}
	if m.Real != 0 {
		n += 5
	}
	if m.Days != 0 {
		n += 1 + sovAnalysis(uint64(m.Days))
	}
	if m.Hours != 0 {
		n += 1 + sovAnalysis(uint64(m.Hours))
	}
	if m.Minutes {
		n += 2
	}
	if m.Seconds {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *QueryGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FieldName)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovAnalysis(uint64(m.Type))
	}
	if m.Interval != nil {
		l = m.Interval.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	l = len(m.OutputField)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.TimezoneSeconds != 0 {
		n += 1 + sovAnalysis(uint64(m.TimezoneSeconds))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Query) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Events) > 0 {
		for _, s := range m.Events {
			l = len(s)
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if m.Range != nil {
		l = m.Range.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if len(m.Sort) > 0 {
		for _, e := range m.Sort {
			l = e.Size()
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if m.Limit != 0 {
		n += 1 + sovAnalysis(uint64(m.Limit))
	}
	if m.Offset != 0 {
		n += 1 + sovAnalysis(uint64(m.Offset))
	}
	if m.GroupBy != nil {
		l = m.GroupBy.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if len(m.Aggregations) > 0 {
		for _, e := range m.Aggregations {
			l = e.Size()
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if len(m.RawQueries) > 0 {
		for _, b := range m.RawQueries {
			l = len(b)
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AnalyzeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChildId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	l = len(m.ProfileId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.UseAppData {
		n += 2
	}
	if m.Query != nil {
		l = m.Query.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if len(m.Games) > 0 {
		for _, e := range m.Games {
			l = e.Size()
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AnalyzeResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Request != nil {
		l = m.Request.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovAnalysis(uint64(m.CreatedAt))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ActiveUsersRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovAnalysis(uint64(m.Type))
	}
	if len(m.Dates) > 0 {
		l = 0
		for _, e := range m.Dates {
			l += sovAnalysis(uint64(e))
		}
		n += 1 + sovAnalysis(uint64(l)) + l
	}
	l = len(m.AppId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ActiveUsersResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Request != nil {
		l = m.Request.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovAnalysis(uint64(m.CreatedAt))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RetentionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovAnalysis(uint64(m.Type))
	}
	if len(m.Dates) > 0 {
		l = 0
		for _, e := range m.Dates {
			l += sovAnalysis(uint64(e))
		}
		n += 1 + sovAnalysis(uint64(l)) + l
	}
	l = len(m.AppId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RetentionResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Request != nil {
		l = m.Request.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovAnalysis(uint64(m.CreatedAt))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *InactiveUsersRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.InactiveDuring != nil {
		l = m.InactiveDuring.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.ActiveDuring != nil {
		l = m.ActiveDuring.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetActiveUsersRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Period != nil {
		l = m.Period.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ActiveOnRangeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Range != nil {
		l = m.Range.Size()
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if len(m.CountryCodes) > 0 {
		for _, s := range m.CountryCodes {
			l = len(s)
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if len(m.AppIds) > 0 {
		for _, s := range m.AppIds {
			l = len(s)
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GameInfoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.GameId)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if len(m.Events) > 0 {
		for _, e := range m.Events {
			l = e.Size()
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GameInfoResponse_FieldInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovAnalysis(uint64(m.Type))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GameInfoResponse_EventInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAnalysis(uint64(l))
	}
	if len(m.Fields) > 0 {
		for _, e := range m.Fields {
			l = e.Size()
			n += 1 + l + sovAnalysis(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AppDataInfoReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovAnalysis(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozAnalysis(x uint64) (n int) {
	return sovAnalysis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TimeRange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TimeRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TimeRange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			m.From = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.From |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			m.To = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.To |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChildAndProfileIds) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ChildAndProfileIds: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChildAndProfileIds: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChildId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChildId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChildAndTimeRange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ChildAndTimeRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChildAndTimeRange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChildId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChildId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Range == nil {
				m.Range = &TimeRange{}
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GameWithVersions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GameWithVersions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GameWithVersions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GameId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GameId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Versions = append(m.Versions, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PlayedGamesList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PlayedGamesList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PlayedGamesList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Games", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Games = append(m.Games, &GameWithVersions{})
			if err := m.Games[len(m.Games)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChildId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChildId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Range == nil {
				m.Range = &TimeRange{}
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QuerySort) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QuerySort: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySort: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FieldName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Order", wireType)
			}
			m.Order = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Order |= QuerySort_SortOrder(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Aggregation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Aggregation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Aggregation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FieldName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutputField = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accumulator", wireType)
			}
			m.Accumulator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Accumulator |= Aggregation_Accumulator(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GroupInterval) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GroupInterval: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GroupInterval: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int", wireType)
			}
			m.Int = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Int |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Real", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Real = float32(math.Float32frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Days", wireType)
			}
			m.Days = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Days |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hours", wireType)
			}
			m.Hours = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Hours |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Minutes", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Minutes = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seconds", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Seconds = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryGroup) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGroup: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FieldName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= QueryGroup_GroupType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Interval == nil {
				m.Interval = &GroupInterval{}
			}
			if err := m.Interval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutputField = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimezoneSeconds", wireType)
			}
			m.TimezoneSeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimezoneSeconds |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Query) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Query: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Query: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Events = append(m.Events, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Range == nil {
				m.Range = &TimeRange{}
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sort = append(m.Sort, &QuerySort{})
			if err := m.Sort[len(m.Sort)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupBy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GroupBy == nil {
				m.GroupBy = &QueryGroup{}
			}
			if err := m.GroupBy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Aggregations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Aggregations = append(m.Aggregations, &Aggregation{})
			if err := m.Aggregations[len(m.Aggregations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawQueries", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RawQueries = append(m.RawQueries, make([]byte, postIndex-iNdEx))
			copy(m.RawQueries[len(m.RawQueries)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalyzeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AnalyzeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalyzeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChildId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChildId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseAppData", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseAppData = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Query == nil {
				m.Query = &Query{}
			}
			if err := m.Query.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Games", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Games = append(m.Games, &GameWithVersions{})
			if err := m.Games[len(m.Games)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AnalyzeResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AnalyzeResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AnalyzeResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Request == nil {
				m.Request = &AnalyzeRequest{}
			}
			if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &DataSet{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ActiveUsersRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ActiveUsersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ActiveUsersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= ActiveUsersRequest_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAnalysis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Dates = append(m.Dates, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAnalysis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthAnalysis
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthAnalysis
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Dates) == 0 {
					m.Dates = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowAnalysis
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Dates = append(m.Dates, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Dates", wireType)
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ActiveUsersResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ActiveUsersResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ActiveUsersResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Request == nil {
				m.Request = &ActiveUsersRequest{}
			}
			if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &DataSet{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RetentionRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RetentionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RetentionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= RetentionRequest_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAnalysis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Dates = append(m.Dates, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAnalysis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthAnalysis
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthAnalysis
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Dates) == 0 {
					m.Dates = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowAnalysis
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Dates = append(m.Dates, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Dates", wireType)
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RetentionResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RetentionResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RetentionResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Request == nil {
				m.Request = &RetentionRequest{}
			}
			if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &DataSet{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InactiveUsersRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InactiveUsersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InactiveUsersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InactiveDuring", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InactiveDuring == nil {
				m.InactiveDuring = &TimeRange{}
			}
			if err := m.InactiveDuring.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveDuring", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ActiveDuring == nil {
				m.ActiveDuring = &TimeRange{}
			}
			if err := m.ActiveDuring.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetActiveUsersRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetActiveUsersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetActiveUsersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Period", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Period == nil {
				m.Period = &TimeRange{}
			}
			if err := m.Period.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ActiveOnRangeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ActiveOnRangeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ActiveOnRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Range == nil {
				m.Range = &TimeRange{}
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CountryCodes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CountryCodes = append(m.CountryCodes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppIds = append(m.AppIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GameInfoResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GameInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GameInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GameId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GameId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Events = append(m.Events, &GameInfoResponse_EventInfo{})
			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GameInfoResponse_FieldInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FieldInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FieldInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= GameInfoResponse_FieldType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GameInfoResponse_EventInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAnalysis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAnalysis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fields = append(m.Fields, &GameInfoResponse_FieldInfo{})
			if err := m.Fields[len(m.Fields)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AppDataInfoReq) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AppDataInfoReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppDataInfoReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAnalysis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAnalysis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipAnalysis(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowAnalysis
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowAnalysis
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthAnalysis
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthAnalysis
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowAnalysis
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipAnalysis(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthAnalysis
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthAnalysis = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAnalysis   = fmt.Errorf("proto: integer overflow")
)