gotapdance/protobuf/signalling.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: signalling.proto

package tdproto

import (
	fmt "fmt"
	proto "github.com/ooni/psiphon/oopsi/github.com/golang/protobuf/proto"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type KeyType int32

const (
	KeyType_AES_GCM_128 KeyType = 90
	KeyType_AES_GCM_256 KeyType = 91
)

var KeyType_name = map[int32]string{
	90: "AES_GCM_128",
	91: "AES_GCM_256",
}

var KeyType_value = map[string]int32{
	"AES_GCM_128": 90,
	"AES_GCM_256": 91,
}

func (x KeyType) Enum() *KeyType {
	p := new(KeyType)
	*p = x
	return p
}

func (x KeyType) String() string {
	return proto.EnumName(KeyType_name, int32(x))
}

func (x *KeyType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(KeyType_value, data, "KeyType")
	if err != nil {
		return err
	}
	*x = KeyType(value)
	return nil
}

func (KeyType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{0}
}

// State transitions of the client
type C2S_Transition int32

const (
	C2S_Transition_C2S_NO_CHANGE                C2S_Transition = 0
	C2S_Transition_C2S_SESSION_INIT             C2S_Transition = 1
	C2S_Transition_C2S_SESSION_COVERT_INIT      C2S_Transition = 11
	C2S_Transition_C2S_EXPECT_RECONNECT         C2S_Transition = 2
	C2S_Transition_C2S_SESSION_CLOSE            C2S_Transition = 3
	C2S_Transition_C2S_YIELD_UPLOAD             C2S_Transition = 4
	C2S_Transition_C2S_ACQUIRE_UPLOAD           C2S_Transition = 5
	C2S_Transition_C2S_EXPECT_UPLOADONLY_RECONN C2S_Transition = 6
	C2S_Transition_C2S_ERROR                    C2S_Transition = 255
)

var C2S_Transition_name = map[int32]string{
	0:   "C2S_NO_CHANGE",
	1:   "C2S_SESSION_INIT",
	11:  "C2S_SESSION_COVERT_INIT",
	2:   "C2S_EXPECT_RECONNECT",
	3:   "C2S_SESSION_CLOSE",
	4:   "C2S_YIELD_UPLOAD",
	5:   "C2S_ACQUIRE_UPLOAD",
	6:   "C2S_EXPECT_UPLOADONLY_RECONN",
	255: "C2S_ERROR",
}

var C2S_Transition_value = map[string]int32{
	"C2S_NO_CHANGE":                0,
	"C2S_SESSION_INIT":             1,
	"C2S_SESSION_COVERT_INIT":      11,
	"C2S_EXPECT_RECONNECT":         2,
	"C2S_SESSION_CLOSE":            3,
	"C2S_YIELD_UPLOAD":             4,
	"C2S_ACQUIRE_UPLOAD":           5,
	"C2S_EXPECT_UPLOADONLY_RECONN": 6,
	"C2S_ERROR":                    255,
}

func (x C2S_Transition) Enum() *C2S_Transition {
	p := new(C2S_Transition)
	*p = x
	return p
}

func (x C2S_Transition) String() string {
	return proto.EnumName(C2S_Transition_name, int32(x))
}

func (x *C2S_Transition) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(C2S_Transition_value, data, "C2S_Transition")
	if err != nil {
		return err
	}
	*x = C2S_Transition(value)
	return nil
}

func (C2S_Transition) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{1}
}

// State transitions of the server
type S2C_Transition int32

const (
	S2C_Transition_S2C_NO_CHANGE           S2C_Transition = 0
	S2C_Transition_S2C_SESSION_INIT        S2C_Transition = 1
	S2C_Transition_S2C_SESSION_COVERT_INIT S2C_Transition = 11
	S2C_Transition_S2C_CONFIRM_RECONNECT   S2C_Transition = 2
	S2C_Transition_S2C_SESSION_CLOSE       S2C_Transition = 3
	// TODO should probably also allow EXPECT_RECONNECT here, for DittoTap
	S2C_Transition_S2C_ERROR S2C_Transition = 255
)

var S2C_Transition_name = map[int32]string{
	0:   "S2C_NO_CHANGE",
	1:   "S2C_SESSION_INIT",
	11:  "S2C_SESSION_COVERT_INIT",
	2:   "S2C_CONFIRM_RECONNECT",
	3:   "S2C_SESSION_CLOSE",
	255: "S2C_ERROR",
}

var S2C_Transition_value = map[string]int32{
	"S2C_NO_CHANGE":           0,
	"S2C_SESSION_INIT":        1,
	"S2C_SESSION_COVERT_INIT": 11,
	"S2C_CONFIRM_RECONNECT":   2,
	"S2C_SESSION_CLOSE":       3,
	"S2C_ERROR":               255,
}

func (x S2C_Transition) Enum() *S2C_Transition {
	p := new(S2C_Transition)
	*p = x
	return p
}

func (x S2C_Transition) String() string {
	return proto.EnumName(S2C_Transition_name, int32(x))
}

func (x *S2C_Transition) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(S2C_Transition_value, data, "S2C_Transition")
	if err != nil {
		return err
	}
	*x = S2C_Transition(value)
	return nil
}

func (S2C_Transition) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{2}
}

// Should accompany all S2C_ERROR messages.
type ErrorReasonS2C int32

const (
	ErrorReasonS2C_NO_ERROR         ErrorReasonS2C = 0
	ErrorReasonS2C_COVERT_STREAM    ErrorReasonS2C = 1
	ErrorReasonS2C_CLIENT_REPORTED  ErrorReasonS2C = 2
	ErrorReasonS2C_CLIENT_PROTOCOL  ErrorReasonS2C = 3
	ErrorReasonS2C_STATION_INTERNAL ErrorReasonS2C = 4
	ErrorReasonS2C_DECOY_OVERLOAD   ErrorReasonS2C = 5
	ErrorReasonS2C_CLIENT_STREAM    ErrorReasonS2C = 100
	ErrorReasonS2C_CLIENT_TIMEOUT   ErrorReasonS2C = 101
)

var ErrorReasonS2C_name = map[int32]string{
	0:   "NO_ERROR",
	1:   "COVERT_STREAM",
	2:   "CLIENT_REPORTED",
	3:   "CLIENT_PROTOCOL",
	4:   "STATION_INTERNAL",
	5:   "DECOY_OVERLOAD",
	100: "CLIENT_STREAM",
	101: "CLIENT_TIMEOUT",
}

var ErrorReasonS2C_value = map[string]int32{
	"NO_ERROR":         0,
	"COVERT_STREAM":    1,
	"CLIENT_REPORTED":  2,
	"CLIENT_PROTOCOL":  3,
	"STATION_INTERNAL": 4,
	"DECOY_OVERLOAD":   5,
	"CLIENT_STREAM":    100,
	"CLIENT_TIMEOUT":   101,
}

func (x ErrorReasonS2C) Enum() *ErrorReasonS2C {
	p := new(ErrorReasonS2C)
	*p = x
	return p
}

func (x ErrorReasonS2C) String() string {
	return proto.EnumName(ErrorReasonS2C_name, int32(x))
}

func (x *ErrorReasonS2C) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ErrorReasonS2C_value, data, "ErrorReasonS2C")
	if err != nil {
		return err
	}
	*x = ErrorReasonS2C(value)
	return nil
}

func (ErrorReasonS2C) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{3}
}

type TransportType int32

const (
	TransportType_Null  TransportType = 0
	TransportType_Min   TransportType = 1
	TransportType_Obfs4 TransportType = 2
)

var TransportType_name = map[int32]string{
	0: "Null",
	1: "Min",
	2: "Obfs4",
}

var TransportType_value = map[string]int32{
	"Null":  0,
	"Min":   1,
	"Obfs4": 2,
}

func (x TransportType) Enum() *TransportType {
	p := new(TransportType)
	*p = x
	return p
}

func (x TransportType) String() string {
	return proto.EnumName(TransportType_name, int32(x))
}

func (x *TransportType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TransportType_value, data, "TransportType")
	if err != nil {
		return err
	}
	*x = TransportType(value)
	return nil
}

func (TransportType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{4}
}

type RegistrationSource int32

const (
	RegistrationSource_Unspecified     RegistrationSource = 0
	RegistrationSource_Detector        RegistrationSource = 1
	RegistrationSource_API             RegistrationSource = 2
	RegistrationSource_DetectorPrescan RegistrationSource = 3
)

var RegistrationSource_name = map[int32]string{
	0: "Unspecified",
	1: "Detector",
	2: "API",
	3: "DetectorPrescan",
}

var RegistrationSource_value = map[string]int32{
	"Unspecified":     0,
	"Detector":        1,
	"API":             2,
	"DetectorPrescan": 3,
}

func (x RegistrationSource) Enum() *RegistrationSource {
	p := new(RegistrationSource)
	*p = x
	return p
}

func (x RegistrationSource) String() string {
	return proto.EnumName(RegistrationSource_name, int32(x))
}

func (x *RegistrationSource) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(RegistrationSource_value, data, "RegistrationSource")
	if err != nil {
		return err
	}
	*x = RegistrationSource(value)
	return nil
}

func (RegistrationSource) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{5}
}

type PubKey struct {
	// A public key, as used by the station.
	Key                  []byte   `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	Type                 *KeyType `protobuf:"varint,2,opt,name=type,enum=tapdance.KeyType" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PubKey) Reset()         { *m = PubKey{} }
func (m *PubKey) String() string { return proto.CompactTextString(m) }
func (*PubKey) ProtoMessage()    {}
func (*PubKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{0}
}

func (m *PubKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PubKey.Unmarshal(m, b)
}
func (m *PubKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PubKey.Marshal(b, m, deterministic)
}
func (m *PubKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PubKey.Merge(m, src)
}
func (m *PubKey) XXX_Size() int {
	return xxx_messageInfo_PubKey.Size(m)
}
func (m *PubKey) XXX_DiscardUnknown() {
	xxx_messageInfo_PubKey.DiscardUnknown(m)
}

var xxx_messageInfo_PubKey proto.InternalMessageInfo

func (m *PubKey) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *PubKey) GetType() KeyType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return KeyType_AES_GCM_128
}

type TLSDecoySpec struct {
	// The hostname/SNI to use for this host
	//
	// The hostname is the only required field, although other
	// fields are expected to be present in most cases.
	Hostname *string `protobuf:"bytes,1,opt,name=hostname" json:"hostname,omitempty"`
	// The 32-bit ipv4 address, in network byte order
	//
	// If the IPv4 address is absent, then it may be resolved via
	// DNS by the client, or the client may discard this decoy spec
	// if local DNS is untrusted, or the service may be multihomed.
	Ipv4Addr *uint32 `protobuf:"fixed32,2,opt,name=ipv4addr" json:"ipv4addr,omitempty"`
	// The 128-bit ipv6 address, in network byte order
	Ipv6Addr []byte `protobuf:"bytes,6,opt,name=ipv6addr" json:"ipv6addr,omitempty"`
	// The Tapdance station public key to use when contacting this
	// decoy
	//
	// If omitted, the default station public key (if any) is used.
	Pubkey *PubKey `protobuf:"bytes,3,opt,name=pubkey" json:"pubkey,omitempty"`
	// The maximum duration, in milliseconds, to maintain an open
	// connection to this decoy (because the decoy may close the
	// connection itself after this length of time)
	//
	// If omitted, a default of 30,000 milliseconds is assumed.
	Timeout *uint32 `protobuf:"varint,4,opt,name=timeout" json:"timeout,omitempty"`
	// The maximum TCP window size to attempt to use for this decoy.
	//
	// If omitted, a default of 15360 is assumed.
	//
	// TODO: the default is based on the current heuristic of only
	// using decoys that permit windows of 15KB or larger.  If this
	// heuristic changes, then this default doesn't make sense.
	Tcpwin               *uint32  `protobuf:"varint,5,opt,name=tcpwin" json:"tcpwin,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TLSDecoySpec) Reset()         { *m = TLSDecoySpec{} }
func (m *TLSDecoySpec) String() string { return proto.CompactTextString(m) }
func (*TLSDecoySpec) ProtoMessage()    {}
func (*TLSDecoySpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{1}
}

func (m *TLSDecoySpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TLSDecoySpec.Unmarshal(m, b)
}
func (m *TLSDecoySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TLSDecoySpec.Marshal(b, m, deterministic)
}
func (m *TLSDecoySpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TLSDecoySpec.Merge(m, src)
}
func (m *TLSDecoySpec) XXX_Size() int {
	return xxx_messageInfo_TLSDecoySpec.Size(m)
}
func (m *TLSDecoySpec) XXX_DiscardUnknown() {
	xxx_messageInfo_TLSDecoySpec.DiscardUnknown(m)
}

var xxx_messageInfo_TLSDecoySpec proto.InternalMessageInfo

func (m *TLSDecoySpec) GetHostname() string {
	if m != nil && m.Hostname != nil {
		return *m.Hostname
	}
	return ""
}

func (m *TLSDecoySpec) GetIpv4Addr() uint32 {
	if m != nil && m.Ipv4Addr != nil {
		return *m.Ipv4Addr
	}
	return 0
}

func (m *TLSDecoySpec) GetIpv6Addr() []byte {
	if m != nil {
		return m.Ipv6Addr
	}
	return nil
}

func (m *TLSDecoySpec) GetPubkey() *PubKey {
	if m != nil {
		return m.Pubkey
	}
	return nil
}

func (m *TLSDecoySpec) GetTimeout() uint32 {
	if m != nil && m.Timeout != nil {
		return *m.Timeout
	}
	return 0
}

func (m *TLSDecoySpec) GetTcpwin() uint32 {
	if m != nil && m.Tcpwin != nil {
		return *m.Tcpwin
	}
	return 0
}

type ClientConf struct {
	DecoyList            *DecoyList          `protobuf:"bytes,1,opt,name=decoy_list,json=decoyList" json:"decoy_list,omitempty"`
	Generation           *uint32             `protobuf:"varint,2,opt,name=generation" json:"generation,omitempty"`
	DefaultPubkey        *PubKey             `protobuf:"bytes,3,opt,name=default_pubkey,json=defaultPubkey" json:"default_pubkey,omitempty"`
	PhantomSubnetsList   *PhantomSubnetsList `protobuf:"bytes,4,opt,name=phantom_subnets_list,json=phantomSubnetsList" json:"phantom_subnets_list,omitempty"`
	ConjurePubkey        *PubKey             `protobuf:"bytes,5,opt,name=conjure_pubkey,json=conjurePubkey" json:"conjure_pubkey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *ClientConf) Reset()         { *m = ClientConf{} }
func (m *ClientConf) String() string { return proto.CompactTextString(m) }
func (*ClientConf) ProtoMessage()    {}
func (*ClientConf) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{2}
}

func (m *ClientConf) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientConf.Unmarshal(m, b)
}
func (m *ClientConf) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientConf.Marshal(b, m, deterministic)
}
func (m *ClientConf) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientConf.Merge(m, src)
}
func (m *ClientConf) XXX_Size() int {
	return xxx_messageInfo_ClientConf.Size(m)
}
func (m *ClientConf) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientConf.DiscardUnknown(m)
}

var xxx_messageInfo_ClientConf proto.InternalMessageInfo

func (m *ClientConf) GetDecoyList() *DecoyList {
	if m != nil {
		return m.DecoyList
	}
	return nil
}

func (m *ClientConf) GetGeneration() uint32 {
	if m != nil && m.Generation != nil {
		return *m.Generation
	}
	return 0
}

func (m *ClientConf) GetDefaultPubkey() *PubKey {
	if m != nil {
		return m.DefaultPubkey
	}
	return nil
}

func (m *ClientConf) GetPhantomSubnetsList() *PhantomSubnetsList {
	if m != nil {
		return m.PhantomSubnetsList
	}
	return nil
}

func (m *ClientConf) GetConjurePubkey() *PubKey {
	if m != nil {
		return m.ConjurePubkey
	}
	return nil
}

type DecoyList struct {
	TlsDecoys            []*TLSDecoySpec `protobuf:"bytes,1,rep,name=tls_decoys,json=tlsDecoys" json:"tls_decoys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *DecoyList) Reset()         { *m = DecoyList{} }
func (m *DecoyList) String() string { return proto.CompactTextString(m) }
func (*DecoyList) ProtoMessage()    {}
func (*DecoyList) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{3}
}

func (m *DecoyList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DecoyList.Unmarshal(m, b)
}
func (m *DecoyList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DecoyList.Marshal(b, m, deterministic)
}
func (m *DecoyList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DecoyList.Merge(m, src)
}
func (m *DecoyList) XXX_Size() int {
	return xxx_messageInfo_DecoyList.Size(m)
}
func (m *DecoyList) XXX_DiscardUnknown() {
	xxx_messageInfo_DecoyList.DiscardUnknown(m)
}

var xxx_messageInfo_DecoyList proto.InternalMessageInfo

func (m *DecoyList) GetTlsDecoys() []*TLSDecoySpec {
	if m != nil {
		return m.TlsDecoys
	}
	return nil
}

type PhantomSubnetsList struct {
	WeightedSubnets      []*PhantomSubnets `protobuf:"bytes,1,rep,name=weighted_subnets,json=weightedSubnets" json:"weighted_subnets,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *PhantomSubnetsList) Reset()         { *m = PhantomSubnetsList{} }
func (m *PhantomSubnetsList) String() string { return proto.CompactTextString(m) }
func (*PhantomSubnetsList) ProtoMessage()    {}
func (*PhantomSubnetsList) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{4}
}

func (m *PhantomSubnetsList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PhantomSubnetsList.Unmarshal(m, b)
}
func (m *PhantomSubnetsList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PhantomSubnetsList.Marshal(b, m, deterministic)
}
func (m *PhantomSubnetsList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PhantomSubnetsList.Merge(m, src)
}
func (m *PhantomSubnetsList) XXX_Size() int {
	return xxx_messageInfo_PhantomSubnetsList.Size(m)
}
func (m *PhantomSubnetsList) XXX_DiscardUnknown() {
	xxx_messageInfo_PhantomSubnetsList.DiscardUnknown(m)
}

var xxx_messageInfo_PhantomSubnetsList proto.InternalMessageInfo

func (m *PhantomSubnetsList) GetWeightedSubnets() []*PhantomSubnets {
	if m != nil {
		return m.WeightedSubnets
	}
	return nil
}

type PhantomSubnets struct {
	Weight               *uint32  `protobuf:"varint,1,opt,name=weight" json:"weight,omitempty"`
	Subnets              []string `protobuf:"bytes,2,rep,name=subnets" json:"subnets,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PhantomSubnets) Reset()         { *m = PhantomSubnets{} }
func (m *PhantomSubnets) String() string { return proto.CompactTextString(m) }
func (*PhantomSubnets) ProtoMessage()    {}
func (*PhantomSubnets) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{5}
}

func (m *PhantomSubnets) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PhantomSubnets.Unmarshal(m, b)
}
func (m *PhantomSubnets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PhantomSubnets.Marshal(b, m, deterministic)
}
func (m *PhantomSubnets) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PhantomSubnets.Merge(m, src)
}
func (m *PhantomSubnets) XXX_Size() int {
	return xxx_messageInfo_PhantomSubnets.Size(m)
}
func (m *PhantomSubnets) XXX_DiscardUnknown() {
	xxx_messageInfo_PhantomSubnets.DiscardUnknown(m)
}

var xxx_messageInfo_PhantomSubnets proto.InternalMessageInfo

func (m *PhantomSubnets) GetWeight() uint32 {
	if m != nil && m.Weight != nil {
		return *m.Weight
	}
	return 0
}

func (m *PhantomSubnets) GetSubnets() []string {
	if m != nil {
		return m.Subnets
	}
	return nil
}

type StationToClient struct {
	// Should accompany (at least) SESSION_INIT and CONFIRM_RECONNECT.
	ProtocolVersion *uint32 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion" json:"protocol_version,omitempty"`
	// There might be a state transition. May be absent; absence should be
	// treated identically to NO_CHANGE.
	StateTransition *S2C_Transition `protobuf:"varint,2,opt,name=state_transition,json=stateTransition,enum=tapdance.S2C_Transition" json:"state_transition,omitempty"`
	// The station can send client config info piggybacked
	// on any message, as it sees fit
	ConfigInfo *ClientConf `protobuf:"bytes,3,opt,name=config_info,json=configInfo" json:"config_info,omitempty"`
	// If state_transition == S2C_ERROR, this field is the explanation.
	ErrReason *ErrorReasonS2C `protobuf:"varint,4,opt,name=err_reason,json=errReason,enum=tapdance.ErrorReasonS2C" json:"err_reason,omitempty"`
	// Signals client to stop connecting for following amount of seconds
	TmpBackoff *uint32 `protobuf:"varint,5,opt,name=tmp_backoff,json=tmpBackoff" json:"tmp_backoff,omitempty"`
	// Sent in SESSION_INIT, identifies the station that picked up
	StationId *string `protobuf:"bytes,6,opt,name=station_id,json=stationId" json:"station_id,omitempty"`
	// Random-sized junk to defeat packet size fingerprinting.
	Padding              []byte   `protobuf:"bytes,100,opt,name=padding" json:"padding,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StationToClient) Reset()         { *m = StationToClient{} }
func (m *StationToClient) String() string { return proto.CompactTextString(m) }
func (*StationToClient) ProtoMessage()    {}
func (*StationToClient) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{6}
}

func (m *StationToClient) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StationToClient.Unmarshal(m, b)
}
func (m *StationToClient) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StationToClient.Marshal(b, m, deterministic)
}
func (m *StationToClient) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StationToClient.Merge(m, src)
}
func (m *StationToClient) XXX_Size() int {
	return xxx_messageInfo_StationToClient.Size(m)
}
func (m *StationToClient) XXX_DiscardUnknown() {
	xxx_messageInfo_StationToClient.DiscardUnknown(m)
}

var xxx_messageInfo_StationToClient proto.InternalMessageInfo

func (m *StationToClient) GetProtocolVersion() uint32 {
	if m != nil && m.ProtocolVersion != nil {
		return *m.ProtocolVersion
	}
	return 0
}

func (m *StationToClient) GetStateTransition() S2C_Transition {
	if m != nil && m.StateTransition != nil {
		return *m.StateTransition
	}
	return S2C_Transition_S2C_NO_CHANGE
}

func (m *StationToClient) GetConfigInfo() *ClientConf {
	if m != nil {
		return m.ConfigInfo
	}
	return nil
}

func (m *StationToClient) GetErrReason() ErrorReasonS2C {
	if m != nil && m.ErrReason != nil {
		return *m.ErrReason
	}
	return ErrorReasonS2C_NO_ERROR
}

func (m *StationToClient) GetTmpBackoff() uint32 {
	if m != nil && m.TmpBackoff != nil {
		return *m.TmpBackoff
	}
	return 0
}

func (m *StationToClient) GetStationId() string {
	if m != nil && m.StationId != nil {
		return *m.StationId
	}
	return ""
}

func (m *StationToClient) GetPadding() []byte {
	if m != nil {
		return m.Padding
	}
	return nil
}

type RegistrationFlags struct {
	UploadOnly           *bool    `protobuf:"varint,1,opt,name=upload_only,json=uploadOnly" json:"upload_only,omitempty"`
	DarkDecoy            *bool    `protobuf:"varint,2,opt,name=dark_decoy,json=darkDecoy" json:"dark_decoy,omitempty"`
	ProxyHeader          *bool    `protobuf:"varint,3,opt,name=proxy_header,json=proxyHeader" json:"proxy_header,omitempty"`
	Use_TIL              *bool    `protobuf:"varint,4,opt,name=use_TIL,json=useTIL" json:"use_TIL,omitempty"`
	Prescanned           *bool    `protobuf:"varint,5,opt,name=prescanned" json:"prescanned,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RegistrationFlags) Reset()         { *m = RegistrationFlags{} }
func (m *RegistrationFlags) String() string { return proto.CompactTextString(m) }
func (*RegistrationFlags) ProtoMessage()    {}
func (*RegistrationFlags) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{7}
}

func (m *RegistrationFlags) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegistrationFlags.Unmarshal(m, b)
}
func (m *RegistrationFlags) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegistrationFlags.Marshal(b, m, deterministic)
}
func (m *RegistrationFlags) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegistrationFlags.Merge(m, src)
}
func (m *RegistrationFlags) XXX_Size() int {
	return xxx_messageInfo_RegistrationFlags.Size(m)
}
func (m *RegistrationFlags) XXX_DiscardUnknown() {
	xxx_messageInfo_RegistrationFlags.DiscardUnknown(m)
}

var xxx_messageInfo_RegistrationFlags proto.InternalMessageInfo

func (m *RegistrationFlags) GetUploadOnly() bool {
	if m != nil && m.UploadOnly != nil {
		return *m.UploadOnly
	}
	return false
}

func (m *RegistrationFlags) GetDarkDecoy() bool {
	if m != nil && m.DarkDecoy != nil {
		return *m.DarkDecoy
	}
	return false
}

func (m *RegistrationFlags) GetProxyHeader() bool {
	if m != nil && m.ProxyHeader != nil {
		return *m.ProxyHeader
	}
	return false
}

func (m *RegistrationFlags) GetUse_TIL() bool {
	if m != nil && m.Use_TIL != nil {
		return *m.Use_TIL
	}
	return false
}

func (m *RegistrationFlags) GetPrescanned() bool {
	if m != nil && m.Prescanned != nil {
		return *m.Prescanned
	}
	return false
}

type ClientToStation struct {
	ProtocolVersion *uint32 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion" json:"protocol_version,omitempty"`
	// The client reports its decoy list's version number here, which the
	// station can use to decide whether to send an updated one. The station
	// should always send a list if this field is set to 0.
	DecoyListGeneration *uint32         `protobuf:"varint,2,opt,name=decoy_list_generation,json=decoyListGeneration" json:"decoy_list_generation,omitempty"`
	StateTransition     *C2S_Transition `protobuf:"varint,3,opt,name=state_transition,json=stateTransition,enum=tapdance.C2S_Transition" json:"state_transition,omitempty"`
	// The position in the overall session's upload sequence where the current
	// YIELD=>ACQUIRE switchover is happening.
	UploadSync *uint64 `protobuf:"varint,4,opt,name=upload_sync,json=uploadSync" json:"upload_sync,omitempty"`
	// List of decoys that client have unsuccessfully tried in current session.
	// Could be sent in chunks
	FailedDecoys []string      `protobuf:"bytes,10,rep,name=failed_decoys,json=failedDecoys" json:"failed_decoys,omitempty"`
	Stats        *SessionStats `protobuf:"bytes,11,opt,name=stats" json:"stats,omitempty"`
	// NullTransport, MinTransport, Obfs4Transport, etc. Transport type we want from phantom proxy
	Transport *TransportType `protobuf:"varint,12,opt,name=transport,enum=tapdance.TransportType" json:"transport,omitempty"`
	// Station is only required to check this variable during session initialization.
	// If set, station must facilitate connection to said target by itself, i.e. write into squid
	// socket an HTTP/SOCKS/any other connection request.
	// covert_address must have exactly one ':' colon, that separates host (literal IP address or
	// resolvable hostname) and port
	// TODO: make it required for initialization, and stop connecting any client straight to squid?
	CovertAddress *string `protobuf:"bytes,20,opt,name=covert_address,json=covertAddress" json:"covert_address,omitempty"`
	// Used in dark decoys to signal which dark decoy it will connect to.
	MaskedDecoyServerName *string `protobuf:"bytes,21,opt,name=masked_decoy_server_name,json=maskedDecoyServerName" json:"masked_decoy_server_name,omitempty"`
	// Used to indicate to server if client is registering v4, v6 or both
	V6Support *bool `protobuf:"varint,22,opt,name=v6_support,json=v6Support" json:"v6_support,omitempty"`
	V4Support *bool `protobuf:"varint,23,opt,name=v4_support,json=v4Support" json:"v4_support,omitempty"`
	// A collection of optional flags for the registration.
	Flags *RegistrationFlags `protobuf:"bytes,24,opt,name=flags" json:"flags,omitempty"`
	// Random-sized junk to defeat packet size fingerprinting.
	Padding              []byte   `protobuf:"bytes,100,opt,name=padding" json:"padding,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClientToStation) Reset()         { *m = ClientToStation{} }
func (m *ClientToStation) String() string { return proto.CompactTextString(m) }
func (*ClientToStation) ProtoMessage()    {}
func (*ClientToStation) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{8}
}

func (m *ClientToStation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientToStation.Unmarshal(m, b)
}
func (m *ClientToStation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientToStation.Marshal(b, m, deterministic)
}
func (m *ClientToStation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientToStation.Merge(m, src)
}
func (m *ClientToStation) XXX_Size() int {
	return xxx_messageInfo_ClientToStation.Size(m)
}
func (m *ClientToStation) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientToStation.DiscardUnknown(m)
}

var xxx_messageInfo_ClientToStation proto.InternalMessageInfo

func (m *ClientToStation) GetProtocolVersion() uint32 {
	if m != nil && m.ProtocolVersion != nil {
		return *m.ProtocolVersion
	}
	return 0
}

func (m *ClientToStation) GetDecoyListGeneration() uint32 {
	if m != nil && m.DecoyListGeneration != nil {
		return *m.DecoyListGeneration
	}
	return 0
}

func (m *ClientToStation) GetStateTransition() C2S_Transition {
	if m != nil && m.StateTransition != nil {
		return *m.StateTransition
	}
	return C2S_Transition_C2S_NO_CHANGE
}

func (m *ClientToStation) GetUploadSync() uint64 {
	if m != nil && m.UploadSync != nil {
		return *m.UploadSync
	}
	return 0
}

func (m *ClientToStation) GetFailedDecoys() []string {
	if m != nil {
		return m.FailedDecoys
	}
	return nil
}

func (m *ClientToStation) GetStats() *SessionStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

func (m *ClientToStation) GetTransport() TransportType {
	if m != nil && m.Transport != nil {
		return *m.Transport
	}
	return TransportType_Null
}

func (m *ClientToStation) GetCovertAddress() string {
	if m != nil && m.CovertAddress != nil {
		return *m.CovertAddress
	}
	return ""
}

func (m *ClientToStation) GetMaskedDecoyServerName() string {
	if m != nil && m.MaskedDecoyServerName != nil {
		return *m.MaskedDecoyServerName
	}
	return ""
}

func (m *ClientToStation) GetV6Support() bool {
	if m != nil && m.V6Support != nil {
		return *m.V6Support
	}
	return false
}

func (m *ClientToStation) GetV4Support() bool {
	if m != nil && m.V4Support != nil {
		return *m.V4Support
	}
	return false
}

func (m *ClientToStation) GetFlags() *RegistrationFlags {
	if m != nil {
		return m.Flags
	}
	return nil
}

func (m *ClientToStation) GetPadding() []byte {
	if m != nil {
		return m.Padding
	}
	return nil
}

type C2SWrapper struct {
	SharedSecret        []byte              `protobuf:"bytes,1,opt,name=shared_secret,json=sharedSecret" json:"shared_secret,omitempty"`
	RegistrationPayload *ClientToStation    `protobuf:"bytes,3,opt,name=registration_payload,json=registrationPayload" json:"registration_payload,omitempty"`
	RegistrationSource  *RegistrationSource `protobuf:"varint,4,opt,name=registration_source,json=registrationSource,enum=tapdance.RegistrationSource" json:"registration_source,omitempty"`
	// client source address when receiving a registration
	RegistrationAddress []byte `protobuf:"bytes,6,opt,name=registration_address,json=registrationAddress" json:"registration_address,omitempty"`
	// Decoy address used when registering over Decoy registrar
	DecoyAddress         []byte   `protobuf:"bytes,7,opt,name=decoy_address,json=decoyAddress" json:"decoy_address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *C2SWrapper) Reset()         { *m = C2SWrapper{} }
func (m *C2SWrapper) String() string { return proto.CompactTextString(m) }
func (*C2SWrapper) ProtoMessage()    {}
func (*C2SWrapper) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{9}
}

func (m *C2SWrapper) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_C2SWrapper.Unmarshal(m, b)
}
func (m *C2SWrapper) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_C2SWrapper.Marshal(b, m, deterministic)
}
func (m *C2SWrapper) XXX_Merge(src proto.Message) {
	xxx_messageInfo_C2SWrapper.Merge(m, src)
}
func (m *C2SWrapper) XXX_Size() int {
	return xxx_messageInfo_C2SWrapper.Size(m)
}
func (m *C2SWrapper) XXX_DiscardUnknown() {
	xxx_messageInfo_C2SWrapper.DiscardUnknown(m)
}

var xxx_messageInfo_C2SWrapper proto.InternalMessageInfo

func (m *C2SWrapper) GetSharedSecret() []byte {
	if m != nil {
		return m.SharedSecret
	}
	return nil
}

func (m *C2SWrapper) GetRegistrationPayload() *ClientToStation {
	if m != nil {
		return m.RegistrationPayload
	}
	return nil
}

func (m *C2SWrapper) GetRegistrationSource() RegistrationSource {
	if m != nil && m.RegistrationSource != nil {
		return *m.RegistrationSource
	}
	return RegistrationSource_Unspecified
}

func (m *C2SWrapper) GetRegistrationAddress() []byte {
	if m != nil {
		return m.RegistrationAddress
	}
	return nil
}

func (m *C2SWrapper) GetDecoyAddress() []byte {
	if m != nil {
		return m.DecoyAddress
	}
	return nil
}

type SessionStats struct {
	FailedDecoysAmount *uint32 `protobuf:"varint,20,opt,name=failed_decoys_amount,json=failedDecoysAmount" json:"failed_decoys_amount,omitempty"`
	// Applicable to whole session:
	TotalTimeToConnect *uint32 `protobuf:"varint,31,opt,name=total_time_to_connect,json=totalTimeToConnect" json:"total_time_to_connect,omitempty"`
	// Last (i.e. successful) decoy:
	RttToStation         *uint32  `protobuf:"varint,33,opt,name=rtt_to_station,json=rttToStation" json:"rtt_to_station,omitempty"`
	TlsToDecoy           *uint32  `protobuf:"varint,38,opt,name=tls_to_decoy,json=tlsToDecoy" json:"tls_to_decoy,omitempty"`
	TcpToDecoy           *uint32  `protobuf:"varint,39,opt,name=tcp_to_decoy,json=tcpToDecoy" json:"tcp_to_decoy,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SessionStats) Reset()         { *m = SessionStats{} }
func (m *SessionStats) String() string { return proto.CompactTextString(m) }
func (*SessionStats) ProtoMessage()    {}
func (*SessionStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{10}
}

func (m *SessionStats) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SessionStats.Unmarshal(m, b)
}
func (m *SessionStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SessionStats.Marshal(b, m, deterministic)
}
func (m *SessionStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SessionStats.Merge(m, src)
}
func (m *SessionStats) XXX_Size() int {
	return xxx_messageInfo_SessionStats.Size(m)
}
func (m *SessionStats) XXX_DiscardUnknown() {
	xxx_messageInfo_SessionStats.DiscardUnknown(m)
}

var xxx_messageInfo_SessionStats proto.InternalMessageInfo

func (m *SessionStats) GetFailedDecoysAmount() uint32 {
	if m != nil && m.FailedDecoysAmount != nil {
		return *m.FailedDecoysAmount
	}
	return 0
}

func (m *SessionStats) GetTotalTimeToConnect() uint32 {
	if m != nil && m.TotalTimeToConnect != nil {
		return *m.TotalTimeToConnect
	}
	return 0
}

func (m *SessionStats) GetRttToStation() uint32 {
	if m != nil && m.RttToStation != nil {
		return *m.RttToStation
	}
	return 0
}

func (m *SessionStats) GetTlsToDecoy() uint32 {
	if m != nil && m.TlsToDecoy != nil {
		return *m.TlsToDecoy
	}
	return 0
}

func (m *SessionStats) GetTcpToDecoy() uint32 {
	if m != nil && m.TcpToDecoy != nil {
		return *m.TcpToDecoy
	}
	return 0
}

type StationToDetector struct {
	PhantomIp            *string  `protobuf:"bytes,1,opt,name=phantom_ip,json=phantomIp" json:"phantom_ip,omitempty"`
	ClientIp             *string  `protobuf:"bytes,2,opt,name=client_ip,json=clientIp" json:"client_ip,omitempty"`
	TimeoutNs            *uint64  `protobuf:"varint,3,opt,name=timeout_ns,json=timeoutNs" json:"timeout_ns,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StationToDetector) Reset()         { *m = StationToDetector{} }
func (m *StationToDetector) String() string { return proto.CompactTextString(m) }
func (*StationToDetector) ProtoMessage()    {}
func (*StationToDetector) Descriptor() ([]byte, []int) {
	return fileDescriptor_39f66308029891ad, []int{11}
}

func (m *StationToDetector) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StationToDetector.Unmarshal(m, b)
}
func (m *StationToDetector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StationToDetector.Marshal(b, m, deterministic)
}
func (m *StationToDetector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StationToDetector.Merge(m, src)
}
func (m *StationToDetector) XXX_Size() int {
	return xxx_messageInfo_StationToDetector.Size(m)
}
func (m *StationToDetector) XXX_DiscardUnknown() {
	xxx_messageInfo_StationToDetector.DiscardUnknown(m)
}

var xxx_messageInfo_StationToDetector proto.InternalMessageInfo

func (m *StationToDetector) GetPhantomIp() string {
	if m != nil && m.PhantomIp != nil {
		return *m.PhantomIp
	}
	return ""
}

func (m *StationToDetector) GetClientIp() string {
	if m != nil && m.ClientIp != nil {
		return *m.ClientIp
	}
	return ""
}

func (m *StationToDetector) GetTimeoutNs() uint64 {
	if m != nil && m.TimeoutNs != nil {
		return *m.TimeoutNs
	}
	return 0
}

func init() {
	proto.RegisterEnum("tapdance.KeyType", KeyType_name, KeyType_value)
	proto.RegisterEnum("tapdance.C2S_Transition", C2S_Transition_name, C2S_Transition_value)
	proto.RegisterEnum("tapdance.S2C_Transition", S2C_Transition_name, S2C_Transition_value)
	proto.RegisterEnum("tapdance.ErrorReasonS2C", ErrorReasonS2C_name, ErrorReasonS2C_value)
	proto.RegisterEnum("tapdance.TransportType", TransportType_name, TransportType_value)
	proto.RegisterEnum("tapdance.RegistrationSource", RegistrationSource_name, RegistrationSource_value)
	proto.RegisterType((*PubKey)(nil), "tapdance.PubKey")
	proto.RegisterType((*TLSDecoySpec)(nil), "tapdance.TLSDecoySpec")
	proto.RegisterType((*ClientConf)(nil), "tapdance.ClientConf")
	proto.RegisterType((*DecoyList)(nil), "tapdance.DecoyList")
	proto.RegisterType((*PhantomSubnetsList)(nil), "tapdance.PhantomSubnetsList")
	proto.RegisterType((*PhantomSubnets)(nil), "tapdance.PhantomSubnets")
	proto.RegisterType((*StationToClient)(nil), "tapdance.StationToClient")
	proto.RegisterType((*RegistrationFlags)(nil), "tapdance.RegistrationFlags")
	proto.RegisterType((*ClientToStation)(nil), "tapdance.ClientToStation")
	proto.RegisterType((*C2SWrapper)(nil), "tapdance.C2SWrapper")
	proto.RegisterType((*SessionStats)(nil), "tapdance.SessionStats")
	proto.RegisterType((*StationToDetector)(nil), "tapdance.StationToDetector")
}

func init() { proto.RegisterFile("signalling.proto", fileDescriptor_39f66308029891ad) }

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