text:
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: api/messages.proto

package pb

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	any "github.com/golang/protobuf/ptypes/any"
	_ "github.com/golang/protobuf/ptypes/struct"
	status "google.golang.org/genproto/googleapis/rpc/status"
	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

// A Ticket is a basic matchmaking entity in Open Match. In order to enter
// matchmaking using Open Match, the client should generate a Ticket, passing in
// the properties to be associated with this Ticket. Open Match will generate an
// ID for a Ticket during creation. A Ticket could be used to represent an
// individual 'Player' or a 'Group' of players. Open Match will not interpret
// what the Ticket represents but just treat it as a matchmaking unit with a set
// of properties. Open Match stores the Ticket in state storage and enables an
// Assignment to be associated with this Ticket.
type Ticket struct {
	// The Ticket ID generated by Open Match.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Assignment associated with the Ticket.
	Assignment *Assignment `protobuf:"bytes,3,opt,name=assignment,proto3" json:"assignment,omitempty"`
	// Values visible to Open Match which can be used when querying for tickets
	// with specific values.
	SearchFields *SearchFields `protobuf:"bytes,4,opt,name=search_fields,json=searchFields,proto3" json:"search_fields,omitempty"`
	// Customized information to be used by the Match Making Function.  Optional,
	// depending on the requirements of the MMF.
	Extension            *any.Any `protobuf:"bytes,5,opt,name=extension,proto3" json:"extension,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Ticket proto.InternalMessageInfo

func (m *Ticket) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Ticket) GetAssignment() *Assignment {
	if m != nil {
		return m.Assignment
	}
	return nil
}

func (m *Ticket) GetSearchFields() *SearchFields {
	if m != nil {
		return m.SearchFields
	}
	return nil
}

func (m *Ticket) GetExtension() *any.Any {
	if m != nil {
		return m.Extension
	}
	return nil
}

// Search fields are the fields which Open Match is aware of, and can be used
// when specifying filters.
type SearchFields struct {
	// Float arguments.  Filterable on ranges.
	DoubleArgs map[string]float64 `protobuf:"bytes,1,rep,name=double_args,json=doubleArgs,proto3" json:"double_args,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	// String arguments.  Filterable on equality.
	StringArgs map[string]string `protobuf:"bytes,2,rep,name=string_args,json=stringArgs,proto3" json:"string_args,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Filterable on presence or absence of given value.
	Tags                 []string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SearchFields proto.InternalMessageInfo

func (m *SearchFields) GetDoubleArgs() map[string]float64 {
	if m != nil {
		return m.DoubleArgs
	}
	return nil
}

func (m *SearchFields) GetStringArgs() map[string]string {
	if m != nil {
		return m.StringArgs
	}
	return nil
}

func (m *SearchFields) GetTags() []string {
	if m != nil {
		return m.Tags
	}
	return nil
}

// An Assignment object represents the assignment associated with a Ticket. Open
// match does not require or inspect any fields on assignment.
type Assignment struct {
	// Connection information for this Assignment.
	Connection string `protobuf:"bytes,1,opt,name=connection,proto3" json:"connection,omitempty"`
	// Error when finding an Assignment for this Ticket.
	Error *status.Status `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	// Customized information to be sent to the clients.  Optional, depending on
	// what callers are expecting.
	Extension            *any.Any `protobuf:"bytes,4,opt,name=extension,proto3" json:"extension,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Assignment proto.InternalMessageInfo

func (m *Assignment) GetConnection() string {
	if m != nil {
		return m.Connection
	}
	return ""
}

func (m *Assignment) GetError() *status.Status {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *Assignment) GetExtension() *any.Any {
	if m != nil {
		return m.Extension
	}
	return nil
}

// Filters numerical values to only those within a range.
//   double_arg: "foo"
//   max: 10
//   min: 5
// matches:
//   {"foo": 5}
//   {"foo": 7.5}
//   {"foo": 10}
// does not match:
//   {"foo": 4}
//   {"foo": 10.01}
//   {"foo": "7.5"}
//   {}
type DoubleRangeFilter struct {
	// Name of the ticket's search_fields.double_args this Filter operates on.
	DoubleArg string `protobuf:"bytes,1,opt,name=double_arg,json=doubleArg,proto3" json:"double_arg,omitempty"`
	// Maximum value. Defaults to positive infinity (any value above minv).
	Max float64 `protobuf:"fixed64,2,opt,name=max,proto3" json:"max,omitempty"`
	// Minimum value. Defaults to 0.
	Min                  float64  `protobuf:"fixed64,3,opt,name=min,proto3" json:"min,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DoubleRangeFilter proto.InternalMessageInfo

func (m *DoubleRangeFilter) GetDoubleArg() string {
	if m != nil {
		return m.DoubleArg
	}
	return ""
}

func (m *DoubleRangeFilter) GetMax() float64 {
	if m != nil {
		return m.Max
	}
	return 0
}

func (m *DoubleRangeFilter) GetMin() float64 {
	if m != nil {
		return m.Min
	}
	return 0
}

// Filters strings exactly equaling a value.
//   string_arg: "foo"
//   value: "bar"
// matches:
//   {"foo": "bar"}
// does not match:
//   {"foo": "baz"}
//   {"bar": "foo"}
//   {}
type StringEqualsFilter struct {
	// Name of the ticket's search_fields.string_args this Filter operates on.
	StringArg            string   `protobuf:"bytes,1,opt,name=string_arg,json=stringArg,proto3" json:"string_arg,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_StringEqualsFilter proto.InternalMessageInfo

func (m *StringEqualsFilter) GetStringArg() string {
	if m != nil {
		return m.StringArg
	}
	return ""
}

func (m *StringEqualsFilter) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

// Filters to the tag being present on the search_fields.
//   tag: "foo"
// matches:
//   ["foo"]
//   ["bar","foo"]
// does not match:
//   ["bar"]
//   []
type TagPresentFilter struct {
	Tag                  string   `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TagPresentFilter proto.InternalMessageInfo

func (m *TagPresentFilter) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

type Pool struct {
	// A developer-chosen human-readable name for this Pool.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Set of Filters indicating the filtering criteria. Selected players must
	// match every Filter.
	DoubleRangeFilters   []*DoubleRangeFilter  `protobuf:"bytes,2,rep,name=double_range_filters,json=doubleRangeFilters,proto3" json:"double_range_filters,omitempty"`
	StringEqualsFilters  []*StringEqualsFilter `protobuf:"bytes,4,rep,name=string_equals_filters,json=stringEqualsFilters,proto3" json:"string_equals_filters,omitempty"`
	TagPresentFilters    []*TagPresentFilter   `protobuf:"bytes,5,rep,name=tag_present_filters,json=tagPresentFilters,proto3" json:"tag_present_filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_Pool proto.InternalMessageInfo

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

func (m *Pool) GetDoubleRangeFilters() []*DoubleRangeFilter {
	if m != nil {
		return m.DoubleRangeFilters
	}
	return nil
}

func (m *Pool) GetStringEqualsFilters() []*StringEqualsFilter {
	if m != nil {
		return m.StringEqualsFilters
	}
	return nil
}

func (m *Pool) GetTagPresentFilters() []*TagPresentFilter {
	if m != nil {
		return m.TagPresentFilters
	}
	return nil
}

// A Roster is a named collection of Ticket IDs. It exists so that a Tickets
// associated with a Match can be labelled to belong to a team, sub-team etc. It
// can also be used to represent the current state of a Match in scenarios such
// as backfill, join-in-progress etc.
type Roster struct {
	// A developer-chosen human-readable name for this Roster.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Tickets belonging to this Roster.
	TicketIds            []string `protobuf:"bytes,2,rep,name=ticket_ids,json=ticketIds,proto3" json:"ticket_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Roster proto.InternalMessageInfo

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

func (m *Roster) GetTicketIds() []string {
	if m != nil {
		return m.TicketIds
	}
	return nil
}

// A MatchProfile is Open Match's representation of a Match specification. It is
// used to indicate the criteria for selecting players for a match. A
// MatchProfile is the input to the API to get matches and is passed to the
// MatchFunction. It contains all the information required by the MatchFunction
// to generate match proposals.
type MatchProfile struct {
	// Name of this match profile.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Set of pools to be queried when generating a match for this MatchProfile.
	// The pool names can be used in empty Rosters to specify composition of a
	// match.
	Pools []*Pool `protobuf:"bytes,3,rep,name=pools,proto3" json:"pools,omitempty"`
	// Set of Rosters for this match request. Could be empty Rosters used to
	// indicate the composition of the generated Match or they could be partially
	// pre-populated Ticket list to be used in scenarios such as backfill / join
	// in progress.
	Rosters []*Roster `protobuf:"bytes,4,rep,name=rosters,proto3" json:"rosters,omitempty"`
	// Customized information on how the match function should run.  Optional,
	// depending on the requirements of the match function.
	Extension            *any.Any `protobuf:"bytes,5,opt,name=extension,proto3" json:"extension,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_MatchProfile proto.InternalMessageInfo

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

func (m *MatchProfile) GetPools() []*Pool {
	if m != nil {
		return m.Pools
	}
	return nil
}

func (m *MatchProfile) GetRosters() []*Roster {
	if m != nil {
		return m.Rosters
	}
	return nil
}

func (m *MatchProfile) GetExtension() *any.Any {
	if m != nil {
		return m.Extension
	}
	return nil
}

// A Match is used to represent a completed match object. It can be generated by
// a MatchFunction as a proposal or can be returned by OpenMatch as a result in
// response to the FetchMatches call.
// When a match is returned by the FetchMatches call, it should contain at least
// one ticket to be considered as valid.
type Match struct {
	// A Match ID that should be passed through the stack for tracing.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3" json:"match_id,omitempty"`
	// Name of the match profile that generated this Match.
	MatchProfile string `protobuf:"bytes,2,opt,name=match_profile,json=matchProfile,proto3" json:"match_profile,omitempty"`
	// Name of the match function that generated this Match.
	MatchFunction string `protobuf:"bytes,3,opt,name=match_function,json=matchFunction,proto3" json:"match_function,omitempty"`
	// Tickets belonging to this match.
	Tickets []*Ticket `protobuf:"bytes,4,rep,name=tickets,proto3" json:"tickets,omitempty"`
	// Set of Rosters that comprise this Match
	Rosters []*Roster `protobuf:"bytes,5,rep,name=rosters,proto3" json:"rosters,omitempty"`
	// Customized information for the evaluator.  Optional, depending on the
	// requirements of the configured evaluator.
	EvaluationInput *any.Any `protobuf:"bytes,7,opt,name=evaluation_input,json=evaluationInput,proto3" json:"evaluation_input,omitempty"`
	// Customized information for how the caller of FetchMatches should handle
	// this match.  Optional, depending on the requirements of the FetchMatches
	// caller.
	Extension            *any.Any `protobuf:"bytes,8,opt,name=extension,proto3" json:"extension,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Match proto.InternalMessageInfo

func (m *Match) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

func (m *Match) GetMatchProfile() string {
	if m != nil {
		return m.MatchProfile
	}
	return ""
}

func (m *Match) GetMatchFunction() string {
	if m != nil {
		return m.MatchFunction
	}
	return ""
}

func (m *Match) GetTickets() []*Ticket {
	if m != nil {
		return m.Tickets
	}
	return nil
}

func (m *Match) GetRosters() []*Roster {
	if m != nil {
		return m.Rosters
	}
	return nil
}

func (m *Match) GetEvaluationInput() *any.Any {
	if m != nil {
		return m.EvaluationInput
	}
	return nil
}

func (m *Match) GetExtension() *any.Any {
	if m != nil {
		return m.Extension
	}
	return nil
}

func init() {
	proto.RegisterType((*Ticket)(nil), "openmatch.Ticket")
	proto.RegisterType((*SearchFields)(nil), "openmatch.SearchFields")
	proto.RegisterMapType((map[string]float64)(nil), "openmatch.SearchFields.DoubleArgsEntry")
	proto.RegisterMapType((map[string]string)(nil), "openmatch.SearchFields.StringArgsEntry")
	proto.RegisterType((*Assignment)(nil), "openmatch.Assignment")
	proto.RegisterType((*DoubleRangeFilter)(nil), "openmatch.DoubleRangeFilter")
	proto.RegisterType((*StringEqualsFilter)(nil), "openmatch.StringEqualsFilter")
	proto.RegisterType((*TagPresentFilter)(nil), "openmatch.TagPresentFilter")
	proto.RegisterType((*Pool)(nil), "openmatch.Pool")
	proto.RegisterType((*Roster)(nil), "openmatch.Roster")
	proto.RegisterType((*MatchProfile)(nil), "openmatch.MatchProfile")
	proto.RegisterType((*Match)(nil), "openmatch.Match")
}

func init() { proto.RegisterFile("api/messages.proto", fileDescriptor_cb9fb1f207fd5b8c) }

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

repository: junty/open-match

repo_name: junty/open-match


text:
DESCRIPTION = "ISDB-T DTV Software Package for Linux for the R-Car Gen3"
LICENSE = "CLOSED"

require include/rcar-gen3-modules-common.inc
require include/dtv-dvd-control.inc

inherit features_check

DEPENDS = " \
    kernel-module-vspmif mmngr-user-module \
    vspmif-user-module kernel-module-vspm \
    omx-user-module kernel-module-uvcs-drv \
    kernel-module-scu-src kernel-module-ssp \
    kernel-module-tddmac kernel-module-tsif \
"

PN = "dtv-user-module"
PR = "r0"

PACKAGE_ARCH = "${MACHINE_ARCH}"

REQUIRED_DISTRO_FEATURES = "dtv"

SRC_URI_DTV_SW = "file://Software.tar.gz"
SRC_URI_DTV_UDF = "file://Reference.tar.gz"

SRC_URI = " \
    ${SRC_URI_DTV_SW} \
    ${SRC_URI_DTV_UDF} \
"

S = "${WORKDIR}"

includedir = "${RENESAS_DATADIR}/include"

# do_configure() nothing
do_configure[noexec] = "1"
# do_compile() nothing
do_compile[noexec] = "1"

do_install() {
    # Create destination folders
    install -d ${D}/${libdir}
    install -d ${D}${RENESAS_DATADIR}/include
    install -d ${D}${RENESAS_DATADIR}/src/dtv/reference

    # Copy library
    install -m 644 ${S}/${baselib}/*.a ${D}/${libdir}/

    # Copy shared header files
    install -m 644 ${S}/include/*.h ${D}${RENESAS_DATADIR}/include

    # Copy reference files
    install -m 644 ${S}/userfunc/*.h ${D}${RENESAS_DATADIR}/src/dtv/reference
    install -m 644 ${S}/userfunc/*.c ${D}${RENESAS_DATADIR}/src/dtv/reference
}

PACKAGES = " \
    ${PN} \
    ${PN}-dev \
    ${PN}-staticdev \
"

FILES_${PN} = ""
ALLOW_EMPTY_${PN} = "1"

FILES_${PN}-dev = " \
    ${RENESAS_DATADIR}/include/*.h \
    ${RENESAS_DATADIR}/src/dtv/reference/* \
"
FILES_${PN}-staticdev = " \
    ${libdir}/*.a \
"
INHIBIT_PACKAGE_DEBUG_SPLIT = "1"

license: MIT

repository: renesas-rcar/meta-renesas

license_type: permissive

repo_name: renesas-rcar/meta-renesas

branch_name: refs/heads/dunfell

gha_license_id: MIT

gha_language: BitBake

extension: bb


text:
SUMMARY = "libdvdcss is a simple library for accessing DVDs like block devices"
DESCRIPTION = "libdvdcss is a simple library designed for accessing DVDs like a block device without having to bother about the decryption."
LICENSE = "GPL-2.0-only"
LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263"

SRC_URI = "http://download.videolan.org/pub/libdvdcss/${PV}/libdvdcss-${PV}.tar.bz2"

inherit autotools

EXTRA_OECONF = " --disable-doc "

SRC_URI[md5sum] = "7b74f2e142b13c9de6dc8d807ab912d4"
SRC_URI[sha256sum] = "78c2ed77ec9c0d8fbed7bf7d3abc82068b8864be494cfad165821377ff3f2575"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded

branch_name: refs/heads/master


text:
@book{Pierce:TAPL,
  author = {Benjamin C. Pierce},
  title = {Types and Programming Languages},
  publisher = {MIT Press},
  year = 2002,
  plclub = {Yes},
  bcp = {Yes},
  keys = {books},
  homepage = {http://www.cis.upenn.edu/~bcpierce/tapl},
  errata = {http://www.cis.upenn.edu/~bcpierce/tapl/errata.txt}
}

@book{Pierce:ATTAPL,
  editor = {Benjamin C. Pierce},
  title = {Advanced Topics in Types and Programming Languages},
  publisher = {MIT Press},
  year = 2005,
  plclub = {Yes},
  bcp = {Yes},
  keys = {books},
  homepage = {http://www.cis.upenn.edu/~bcpierce/attapl}
}

@book{Harper:PFPL,
 author = {Harper, Robert},
 title = {Practical Foundations for Programming Languages},
 year = {2012},
 isbn = {1107029570, 9781107029576},
 publisher = {Cambridge University Press},
 address = {New York, NY, USA}
}

@inproceedings{Felleisen-CK-CEK,
    author = {Felleisen, Matthias and Friedman, Daniel P.},
    booktitle = {3rd Working Conference on the Formal Description of Programming Concepts},
    citeulike-article-id = {5906202},
    keywords = {cek},
    month = aug,
    posted-at = {2011-07-13 07:58:05},
    priority = {2},
    title = {{Control operators, the SECD-machine, and the lambda-calculus}},
    year = {1986}
}

@article{Friedman-Lazy-Krivine,
 author = {Friedman, Daniel P. and Ghuloum, Abdulaziz and Siek, Jeremy G. and Winebarger, Onnie Lynn},
 title = {Improving the {L}azy {K}rivine {M}achine},
 journal = {Higher Order Symbol. Comput.},
 issue_date = {September 2007},
 volume = {20},
 number = {3},
 month = sep,
 year = {2007},
 issn = {1388-3690},
 pages = {271--293},
 numpages = {23},
 url = {http://dx.doi.org/10.1007/s10990-007-9014-0},
 doi = {10.1007/s10990-007-9014-0},
 acmid = {1325155},
 publisher = {Kluwer Academic Publishers},
 address = {Hingham, MA, USA},
 keywords = {Abstract machine, Call by need, Lambda calculus, Lazy evaluation},
}

@article{Felleisen-Hieb,
 author = {Felleisen, Matthias and Hieb, Robert},
 title = {The Revised Report on the Syntactic Theories of Sequential Control and State},
 journal = {Theor. Comput. Sci.},
 issue_date = {14 Sept. 1992},
 volume = {103},
 number = {2},
 month = sep,
 year = {1992},
 issn = {0304-3975},
 pages = {235--271},
 numpages = {37},
 url = {http://dx.doi.org/10.1016/0304-3975(92)90014-7},
 doi = {10.1016/0304-3975(92)90014-7},
 acmid = {136297},
 publisher = {Elsevier Science Publishers Ltd.},
 address = {Essex, UK},
}

@phdthesis{Girard-thesis,
  author = {Jean-Yves Girard},
  title = {Interprétation fonctionnelle et élimination des
                 coupures de l'arith\-mé\-ti\-que d'ordre supérieur},
  school = {Universit{\'e} Paris 7},
  type = {Th\`ese d'\'Etat},
  month = jun,
  year = {1972}
}

@inproceedings{reynolds-type-structure,
  author = {John C. Reynolds},
  title = {Towards a theory of type structure},
  booktitle = {Colloque sur la Programmation},
  pages = {408--425},
  year = {1974},}
  volume = {19},
  series = {Lecture Notes in Computer Science},
  month = apr,
  publisher = {Springer},
  url = {http://www.springerlink.com/content/p5801737k78207p7/}
}

@unpublished{Scott-encoding,
  author = {Dana Scott},
  title = {A System of Functional Abstraction},
  year = {1963},
  note = {Unpublished lecture notes}
}

@inproceedings{Koopman:2014,
 author = {Koopman, Pieter and Plasmeijer, Rinus and Jansen, Jan Martin},
 title = {Church Encoding of Data Types Considered Harmful for Implementations: Functional Pearl},
 booktitle = {Proceedings of the 26Nd 2014 International Symposium on Implementation and Application of Functional Languages},
 series = {IFL '14},
 year = {2014},
 isbn = {978-1-4503-3284-2},
 location = {Boston, MA, USA},
 pages = {4:1--4:12},
 articleno = {4},
 numpages = {12},
 url = {http://doi.acm.org/10.1145/2746325.2746330},
 doi = {10.1145/2746325.2746330},
 acmid = {2746330},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Church Numbers, Data Types, Implementation, Parigot Encoding, Scott Encoding},
}

@article{Ahmed:2017,
 author = {Ahmed, Amal and Jamner, Dustin and Siek, Jeremy G. and Wadler, Philip},
 title = {Theorems for Free for Free: Parametricity, with and Without Types},
 journal = {Proc. ACM Program. Lang.},
 issue_date = {September 2017},
 volume = {1},
 number = {ICFP},
 month = aug,
 year = {2017},
 issn = {2475-1421},
 pages = {39:1--39:28},
 articleno = {39},
 numpages = {28},
 url = {http://doi.acm.org/10.1145/3110283},
 doi = {10.1145/3110283},
 acmid = {3110283},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {dynamic typing, gradual typing, logical relation, parametricity},
}

@MISC{Geuvers-2014,
    author = {Geuvers, Herman},
    title = {The {Church-Scott} representation of inductive and coinductive data},
    year = {2014},
    howpublished = {Types 2014, Paris, Draft. \url{http://www.cs.ru.nl/~herman/PUBS/ChurchScottDataTypes.pdf}}
}

% This appears to be the paper where the term "pattern functor" first appeared explicitly.
@inproceedings{backhouseetal98,
  AUTHOR   = "Backhouse, R. and Jansson, P. and Jeuring, J. and Meertens, L.",
  TITLE    = "Generic Programming --- An Introduction",
  booktitle= {LNCS},
  PAGES    = "28--115",
  VOLUME   = "1608",
  PUBLISHER= "Springer-Verlag",
  NOTE     = "Revised version of lecture notes for AFP'98.",
  YEAR     = "1999"
  }

@inproceedings{Yakushev2009,
 author = {Yakushev, Alexey Rodriguez and Holdermans, Stefan and L\"{o}h, Andres and Jeuring, Johan},
 title = {Generic Programming with Fixed Points for Mutually Recursive Datatypes},
 booktitle = {Proceedings of the 14th ACM SIGPLAN International Conference on Functional Programming},
 series = {ICFP '09},
 year = {2009},
 isbn = {978-1-60558-332-7},
 location = {Edinburgh, Scotland},
 pages = {233--244},
 numpages = {12},
 url = {http://doi.acm.org/10.1145/1596550.1596585},
 doi = {10.1145/1596550.1596585},
 acmid = {1596585},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {datatype-generic programming, fixed points, haskell, mutually recursive datatypes},
}

@book{Princeton-bitcoin-book,
 author = {Narayanan, Arvind and Bonneau, Joseph and Felten, Edward and Miller, Andrew and Goldfeder, Steven},
 title = {Bitcoin and Cryptocurrency Technologies: A Comprehensive Introduction},
 year = {2016},
 isbn = {0691171696, 9780691171692},
 publisher = {Princeton University Press},
 address = {Princeton, NJ, USA},
}

@article{Zahnentferner18-Chimeric,
  author    = {Joachim Zahnentferner},
  title     = {Chimeric Ledgers: Translating and Unifying {UTxO}-based and Account-based
               Cryptocurrencies},
  journal   = {{IACR} Cryptology ePrint Archive},
  volume    = {2018},
  pages     = {262},
  year      = {2018},
  url       = {http://eprint.iacr.org/2018/262},
  timestamp = {Tue, 14 Aug 2018 17:08:26 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/iacr/Zahnentferner18},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{Zahnentferner18-UTxO,
  author    = {Joachim Zahnentferner},
  title     = {An Abstract Model of UTxO-based Cryptocurrencies with Scripts},
  journal   = {{IACR} Cryptology ePrint Archive},
  volume    = {2018},
  pages     = {469},
  year      = {2018},
  url       = {https://eprint.iacr.org/2018/469},
  timestamp = {Tue, 14 Aug 2018 17:08:11 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/iacr/Zahnentferner18a},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

repository: m-alvarez/plutus

repo_name: m-alvarez/plutus

gha_language: Haskell

extension: bib


text:
@online{GitHub,
  author = {GitHub},
  title = {GitHub.com},
  year = 2008,
  url = {https://github.com},
  urldate = {2016-02-14}
}

@online{Fidgit,
  author = {Matthieu Gomez},
  title = {InteractiveFixedEffectModels.jl:  A Julia package to estimate linear models with interactive fixed effects},
  year = 2017,
  url = {https://github.com/matthieugomez/InteractiveFixedEffectModels.jl},
  urldate = {2017-04-24}
}

@article{bai2009panel,
  title={Panel data models with interactive fixed effects},
  author={Bai, Jushan},
  journal={Econometrica},
  volume={77},
  number={4},
  pages={1229--1279},
  year={2009},
  publisher={Wiley Online Library}
}

@article{levenberg1944method,
  title={A method for the solution of certain non-linear problems in least squares},
  author={Levenberg, Kenneth},
  journal={Quarterly of applied mathematics},
  volume={2},
  number={2},
  pages={164--168},
  year={1944}
}

@article{marquardt1963algorithm,
  title={An algorithm for least-squares estimation of nonlinear parameters},
  author={Marquardt, Donald W},
  journal={Journal of the society for Industrial and Applied Mathematics},
  volume={11},
  number={2},
  pages={431--441},
  year={1963},
  publisher={SIAM}
}

@article{wright1985inexact,
  title={An inexact levenberg-marquardt method for large sparse nonlinear least squres},
  author={Wright, SJ and Holt, John Norman},
  journal={The Journal of the Australian Mathematical Society. Series B. Applied Mathematics},
  volume={26},
  number={04},
  pages={387--403},
  year={1985},
  publisher={Cambridge Univ Press}
}


text:
FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"

require secure-odroid.inc

COMPATIBLE_MACHINE  = "odroid-c2"


text:
// Copyright 2013 By Jshi. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package views

import (
	. "gwk/vango"
	"image"
)

func (h *HostWindow) OnHostPaint(ctxt NativeContext, dirty_rect image.Rectangle) {
	var canvas = NewNativeCanvas(dirty_rect)
	defer canvas.Release()

	var canvas_rect = dirty_rect.Sub(dirty_rect.Min)

	canvas.DrawCanvas(canvas_rect.Min.X, canvas_rect.Min.Y,
		h.root_view.Canvas(), &dirty_rect)
	canvas.BlitToContext(ctxt, dirty_rect.Min.X, dirty_rect.Min.Y, &canvas_rect)
}

func (h *HostWindow) SetRootView(root_view *RootView) {
	h.root_view = root_view
	if root_view.HostWindow() != h {
		root_view.SetHostWindow(h)
	}
}

func (h *HostWindow) RootView() *RootView {
	return h.root_view
}

extension: go


text:
@incollection{bahadur_handedness_2019,
 author = {Silva, Pedro E. S. and de Abreu, Fernão Vistulo and Correia, Ana Isabel D. and Godinho, Maria Helena},
 booktitle = {Asymmetry in Plants},
 copyright = {All rights reserved},
 doi = {10.1201/9780429492372-13},
 edition = {1},
 editor = {Bahadur, Bir and Krishnamurthy, K. V. and Ghose, Monoranjan and Adams, S. John},
 isbn = {978-0-429-49237-2},
 language = {en},
 month = {March},
 pages = {179--192},
 publisher = {CRC Press},
 title = {Handedness in Plant Tendrils},
 year = {2019}
}