text:
package k8s_io_api_node_v1beta1

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	io "io"
	v11 "istio.io/gogo-genproto/k8s.io/api/core/v1"
	resource "istio.io/gogo-genproto/k8s.io/apimachinery/pkg/api/resource"
	v1 "istio.io/gogo-genproto/k8s.io/apimachinery/pkg/apis/meta/v1"
	_ "istio.io/gogo-genproto/k8s.io/apimachinery/pkg/runtime"
	_ "istio.io/gogo-genproto/k8s.io/apimachinery/pkg/runtime/schema"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

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

// Overhead structure represents the resource overhead associated with running a pod.
type Overhead struct {
	// PodFixed represents the fixed resource overhead associated with running a pod.
	// +optional
	PodFixed map[string]*resource.Quantity `protobuf:"bytes,1,rep,name=podFixed" json:"podFixed,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}

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

var xxx_messageInfo_Overhead proto.InternalMessageInfo

func (m *Overhead) GetPodFixed() map[string]*resource.Quantity {
	if m != nil {
		return m.PodFixed
	}
	return nil
}

// RuntimeClass defines a class of container runtime supported in the cluster.
// The RuntimeClass is used to determine which container runtime is used to run
// all containers in a pod. RuntimeClasses are (currently) manually defined by a
// user or cluster provisioner, and referenced in the PodSpec. The Kubelet is
// responsible for resolving the RuntimeClassName reference before running the
// pod.  For more details, see
// https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md
type RuntimeClass struct {
	// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata
	// +optional
	Metadata *v1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata" json:"metadata,omitempty"`
	// Handler specifies the underlying runtime and configuration that the CRI
	// implementation will use to handle pods of this class. The possible values
	// are specific to the node & CRI configuration.  It is assumed that all
	// handlers are available on every node, and handlers of the same name are
	// equivalent on every node.
	// For example, a handler called "runc" might specify that the runc OCI
	// runtime (using native Linux containers) will be used to run the containers
	// in a pod.
	// The Handler must conform to the DNS Label (RFC 1123) requirements, and is
	// immutable.
	Handler string `protobuf:"bytes,2,opt,name=handler" json:"handler"`
	// Overhead represents the resource overhead associated with running a pod for a
	// given RuntimeClass. For more details, see
	// https://git.k8s.io/enhancements/keps/sig-node/20190226-pod-overhead.md
	// This field is alpha-level as of Kubernetes v1.15, and is only honored by servers that enable the PodOverhead feature.
	// +optional
	Overhead *Overhead `protobuf:"bytes,3,opt,name=overhead" json:"overhead,omitempty"`
	// Scheduling holds the scheduling constraints to ensure that pods running
	// with this RuntimeClass are scheduled to nodes that support it.
	// If scheduling is nil, this RuntimeClass is assumed to be supported by all
	// nodes.
	// +optional
	Scheduling *Scheduling `protobuf:"bytes,4,opt,name=scheduling" json:"scheduling,omitempty"`
}

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

var xxx_messageInfo_RuntimeClass proto.InternalMessageInfo

func (m *RuntimeClass) GetMetadata() *v1.ObjectMeta {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *RuntimeClass) GetHandler() string {
	if m != nil {
		return m.Handler
	}
	return ""
}

func (m *RuntimeClass) GetOverhead() *Overhead {
	if m != nil {
		return m.Overhead
	}
	return nil
}

func (m *RuntimeClass) GetScheduling() *Scheduling {
	if m != nil {
		return m.Scheduling
	}
	return nil
}

// RuntimeClassList is a list of RuntimeClass objects.
type RuntimeClassList struct {
	// Standard list metadata.
	// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata
	// +optional
	Metadata *v1.ListMeta `protobuf:"bytes,1,opt,name=metadata" json:"metadata,omitempty"`
	// Items is a list of schema objects.
	Items []*RuntimeClass `protobuf:"bytes,2,rep,name=items" json:"items,omitempty"`
}

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

var xxx_messageInfo_RuntimeClassList proto.InternalMessageInfo

func (m *RuntimeClassList) GetMetadata() *v1.ListMeta {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *RuntimeClassList) GetItems() []*RuntimeClass {
	if m != nil {
		return m.Items
	}
	return nil
}

// Scheduling specifies the scheduling constraints for nodes supporting a
// RuntimeClass.
type Scheduling struct {
	// nodeSelector lists labels that must be present on nodes that support this
	// RuntimeClass. Pods using this RuntimeClass can only be scheduled to a
	// node matched by this selector. The RuntimeClass nodeSelector is merged
	// with a pod's existing nodeSelector. Any conflicts will cause the pod to
	// be rejected in admission.
	// +optional
	NodeSelector map[string]string `protobuf:"bytes,1,rep,name=nodeSelector" json:"nodeSelector,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// tolerations are appended (excluding duplicates) to pods running with this
	// RuntimeClass during admission, effectively unioning the set of nodes
	// tolerated by the pod and the RuntimeClass.
	// +optional
	// +listType=atomic
	Tolerations []*v11.Toleration `protobuf:"bytes,2,rep,name=tolerations" json:"tolerations,omitempty"`
}

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

var xxx_messageInfo_Scheduling proto.InternalMessageInfo

func (m *Scheduling) GetNodeSelector() map[string]string {
	if m != nil {
		return m.NodeSelector
	}
	return nil
}

func (m *Scheduling) GetTolerations() []*v11.Toleration {
	if m != nil {
		return m.Tolerations
	}
	return nil
}

func init() {
	proto.RegisterType((*Overhead)(nil), "k8s.io.api.node.v1beta1.Overhead")
	proto.RegisterMapType((map[string]*resource.Quantity)(nil), "k8s.io.api.node.v1beta1.Overhead.PodFixedEntry")
	proto.RegisterType((*RuntimeClass)(nil), "k8s.io.api.node.v1beta1.RuntimeClass")
	proto.RegisterType((*RuntimeClassList)(nil), "k8s.io.api.node.v1beta1.RuntimeClassList")
	proto.RegisterType((*Scheduling)(nil), "k8s.io.api.node.v1beta1.Scheduling")
	proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.node.v1beta1.Scheduling.NodeSelectorEntry")
}

func init() {
	proto.RegisterFile("k8s.io/api/node/v1beta1/generated.proto", fileDescriptor_73bb62abe8438af4)
}

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

func (this *Overhead) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Overhead)
	if !ok {
		that2, ok := that.(Overhead)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.PodFixed) != len(that1.PodFixed) {
		return false
	}
	for i := range this.PodFixed {
		if !this.PodFixed[i].Equal(that1.PodFixed[i]) {
			return false
		}
	}
	return true
}
func (this *RuntimeClass) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RuntimeClass)
	if !ok {
		that2, ok := that.(RuntimeClass)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	if this.Handler != that1.Handler {
		return false
	}
	if !this.Overhead.Equal(that1.Overhead) {
		return false
	}
	if !this.Scheduling.Equal(that1.Scheduling) {
		return false
	}
	return true
}
func (this *RuntimeClassList) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RuntimeClassList)
	if !ok {
		that2, ok := that.(RuntimeClassList)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	if len(this.Items) != len(that1.Items) {
		return false
	}
	for i := range this.Items {
		if !this.Items[i].Equal(that1.Items[i]) {
			return false
		}
	}
	return true
}
func (this *Scheduling) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Scheduling)
	if !ok {
		that2, ok := that.(Scheduling)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NodeSelector) != len(that1.NodeSelector) {
		return false
	}
	for i := range this.NodeSelector {
		if this.NodeSelector[i] != that1.NodeSelector[i] {
			return false
		}
	}
	if len(this.Tolerations) != len(that1.Tolerations) {
		return false
	}
	for i := range this.Tolerations {
		if !this.Tolerations[i].Equal(that1.Tolerations[i]) {
			return false
		}
	}
	return true
}
func (this *Overhead) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&k8s_io_api_node_v1beta1.Overhead{")
	keysForPodFixed := make([]string, 0, len(this.PodFixed))
	for k, _ := range this.PodFixed {
		keysForPodFixed = append(keysForPodFixed, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForPodFixed)
	mapStringForPodFixed := "map[string]*resource.Quantity{"
	for _, k := range keysForPodFixed {
		mapStringForPodFixed += fmt.Sprintf("%#v: %#v,", k, this.PodFixed[k])
	}
	mapStringForPodFixed += "}"
	if this.PodFixed != nil {
		s = append(s, "PodFixed: "+mapStringForPodFixed+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RuntimeClass) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&k8s_io_api_node_v1beta1.RuntimeClass{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	s = append(s, "Handler: "+fmt.Sprintf("%#v", this.Handler)+",\n")
	if this.Overhead != nil {
		s = append(s, "Overhead: "+fmt.Sprintf("%#v", this.Overhead)+",\n")
	}
	if this.Scheduling != nil {
		s = append(s, "Scheduling: "+fmt.Sprintf("%#v", this.Scheduling)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RuntimeClassList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&k8s_io_api_node_v1beta1.RuntimeClassList{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	if this.Items != nil {
		s = append(s, "Items: "+fmt.Sprintf("%#v", this.Items)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Scheduling) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&k8s_io_api_node_v1beta1.Scheduling{")
	keysForNodeSelector := make([]string, 0, len(this.NodeSelector))
	for k, _ := range this.NodeSelector {
		keysForNodeSelector = append(keysForNodeSelector, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
	mapStringForNodeSelector := "map[string]string{"
	for _, k := range keysForNodeSelector {
		mapStringForNodeSelector += fmt.Sprintf("%#v: %#v,", k, this.NodeSelector[k])
	}
	mapStringForNodeSelector += "}"
	if this.NodeSelector != nil {
		s = append(s, "NodeSelector: "+mapStringForNodeSelector+",\n")
	}
	if this.Tolerations != nil {
		s = append(s, "Tolerations: "+fmt.Sprintf("%#v", this.Tolerations)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringGenerated(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Overhead) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Overhead) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Overhead) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PodFixed) > 0 {
		for k := range m.PodFixed {
			v := m.PodFixed[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintGenerated(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *RuntimeClass) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RuntimeClass) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Scheduling != nil {
		{
			size, err := m.Scheduling.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Overhead != nil {
		{
			size, err := m.Overhead.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	i -= len(m.Handler)
	copy(dAtA[i:], m.Handler)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Handler)))
	i--
	dAtA[i] = 0x12
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RuntimeClassList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RuntimeClassList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Scheduling) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Scheduling) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Tolerations) > 0 {
		for iNdEx := len(m.Tolerations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tolerations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.NodeSelector) > 0 {
		for k := range m.NodeSelector {
			v := m.NodeSelector[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
	offset -= sovGenerated(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Overhead) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PodFixed) > 0 {
		for k, v := range m.PodFixed {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovGenerated(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *RuntimeClass) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.Handler)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Overhead != nil {
		l = m.Overhead.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Scheduling != nil {
		l = m.Scheduling.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *RuntimeClassList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Items) > 0 {
		for _, e := range m.Items {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *Scheduling) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NodeSelector) > 0 {
		for k, v := range m.NodeSelector {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if len(m.Tolerations) > 0 {
		for _, e := range m.Tolerations {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func sovGenerated(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenerated(x uint64) (n int) {
	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Overhead) String() string {
	if this == nil {
		return "nil"
	}
	keysForPodFixed := make([]string, 0, len(this.PodFixed))
	for k, _ := range this.PodFixed {
		keysForPodFixed = append(keysForPodFixed, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForPodFixed)
	mapStringForPodFixed := "map[string]*resource.Quantity{"
	for _, k := range keysForPodFixed {
		mapStringForPodFixed += fmt.Sprintf("%v: %v,", k, this.PodFixed[k])
	}
	mapStringForPodFixed += "}"
	s := strings.Join([]string{`&Overhead{`,
		`PodFixed:` + mapStringForPodFixed + `,`,
		`}`,
	}, "")
	return s
}
func (this *RuntimeClass) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RuntimeClass{`,
		`Metadata:` + strings.Replace(fmt.Sprintf("%v", this.Metadata), "ObjectMeta", "v1.ObjectMeta", 1) + `,`,
		`Handler:` + fmt.Sprintf("%v", this.Handler) + `,`,
		`Overhead:` + strings.Replace(this.Overhead.String(), "Overhead", "Overhead", 1) + `,`,
		`Scheduling:` + strings.Replace(this.Scheduling.String(), "Scheduling", "Scheduling", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RuntimeClassList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]*RuntimeClass{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(f.String(), "RuntimeClass", "RuntimeClass", 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&RuntimeClassList{`,
		`Metadata:` + strings.Replace(fmt.Sprintf("%v", this.Metadata), "ListMeta", "v1.ListMeta", 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *Scheduling) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTolerations := "[]*Toleration{"
	for _, f := range this.Tolerations {
		repeatedStringForTolerations += strings.Replace(fmt.Sprintf("%v", f), "Toleration", "v11.Toleration", 1) + ","
	}
	repeatedStringForTolerations += "}"
	keysForNodeSelector := make([]string, 0, len(this.NodeSelector))
	for k, _ := range this.NodeSelector {
		keysForNodeSelector = append(keysForNodeSelector, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
	mapStringForNodeSelector := "map[string]string{"
	for _, k := range keysForNodeSelector {
		mapStringForNodeSelector += fmt.Sprintf("%v: %v,", k, this.NodeSelector[k])
	}
	mapStringForNodeSelector += "}"
	s := strings.Join([]string{`&Scheduling{`,
		`NodeSelector:` + mapStringForNodeSelector + `,`,
		`Tolerations:` + repeatedStringForTolerations + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringGenerated(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Overhead) 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 ErrIntOverflowGenerated
			}
			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: Overhead: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Overhead: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodFixed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PodFixed == nil {
				m.PodFixed = make(map[string]*resource.Quantity)
			}
			var mapkey string
			var mapvalue *resource.Quantity
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGenerated
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGenerated
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.PodFixed[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RuntimeClass) 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 ErrIntOverflowGenerated
			}
			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: RuntimeClass: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RuntimeClass: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &v1.ObjectMeta{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Handler", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Handler = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Overhead", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Overhead == nil {
				m.Overhead = &Overhead{}
			}
			if err := m.Overhead.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scheduling", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Scheduling == nil {
				m.Scheduling = &Scheduling{}
			}
			if err := m.Scheduling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RuntimeClassList) 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 ErrIntOverflowGenerated
			}
			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: RuntimeClassList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RuntimeClassList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &v1.ListMeta{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &RuntimeClass{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Scheduling) 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 ErrIntOverflowGenerated
			}
			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: Scheduling: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Scheduling: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeSelector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeSelector == nil {
				m.NodeSelector = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NodeSelector[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tolerations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tolerations = append(m.Tolerations, &v11.Toleration{})
			if err := m.Tolerations[len(m.Tolerations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGenerated(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowGenerated
			}
			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, ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated
				}
				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, ErrInvalidLengthGenerated
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGenerated
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGenerated
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
)


text:
package org.locationtech.geomesa.accumulo.audit

import org.apache.accumulo.core.client.Connector
import org.joda.time.Interval
import org.locationtech.geomesa.accumulo.security.AccumuloAuthsProvider
import org.locationtech.geomesa.index.audit.QueryEvent
import org.locationtech.geomesa.utils.audit._

import scala.reflect.ClassTag

class AccumuloAuditService(connector: Connector,
                           authProvider: AccumuloAuthsProvider,
                           val table: String,
                           write: Boolean) extends AuditWriter with AuditReader with AuditLogger {

  private val writer = if (write) new AccumuloEventWriter(connector, table) else null
  private val reader = new AccumuloEventReader(connector, table)

  override def writeEvent[T <: AuditedEvent](event: T)(implicit ct: ClassTag[T]): Unit = {
    if (writer != null) {
      writer.queueStat(event)(transform(ct.runtimeClass.asInstanceOf[Class[T]]))
    }
    super.writeEvent(event)
  }

  override def getEvents[T <: AuditedEvent](typeName: String, dates: Interval)(implicit ct: ClassTag[T]): Iterator[T] = {
    val iter = reader.query(typeName, dates, authProvider.getAuthorizations)(transform(ct.runtimeClass.asInstanceOf[Class[T]]))
    iter.asInstanceOf[Iterator[T]]
  }

  override def close(): Unit = if (writer != null) { writer.close() }

  // note: only query audit events are currently supported
  private def transform[T <: AuditedEvent](clas: Class[T]): AccumuloEventTransform[T] = {
    val transform = clas match {
      case c if classOf[QueryEvent].isAssignableFrom(c) => AccumuloQueryEventTransform
      case c if classOf[SerializedQueryEvent].isAssignableFrom(c) => SerializedQueryEventTransform
      case _ => throw new NotImplementedError(s"Event of type '${clas.getName}' is not supported")
    }
    transform.asInstanceOf[AccumuloEventTransform[T]]
  }
}

object AccumuloAuditService {
  val StoreType = "accumulo-vector"
}

redpajama_set_name: RedPajamaGithub


text:
leetcode_solutions
==================

My leetcode solutions


text:
using System;
using System.Web;
using System.Web.UI;

public partial class CMS_NewDocPage : Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!HttpContext.Current.User.IsInRole("Content Editor"))
            Response.Redirect("~/CMS/Default.aspx");
    }
}


text:
/**
 * Routes for express app
 */
import passport from 'passport';
import unsupportedMessage from '../db/unsupportedMessage';
import { controllers, passport as passportConfig } from '../db';

const usersController = controllers && controllers.users;
const topicsController = controllers && controllers.topics;

import stocks from '../routes/stocks';

function sanitizeOutput(req, res, next) {
  console.log('here in sanitize!');
  let send = res.send;

  res.send = function(data) {

    console.log('types of Args are!', typeof arguments[0]);
    if (typeof arguments[0] === 'object') {
      arguments[0].newObj = 'test';
    }
    console.log('Args are!', arguments[0]);

    return send.apply(res, arguments);
  }

  next();
}

export default (app) => {

  app.get('/test-route', (req, res) => {
    res.status(200).send({ result: 'Successful!' })
  });

  // app.use(sanitizeOutput);

  stocks(app);

  // user routes
  if (usersController) {
    app.post('/sessions', usersController.login);
    app.post('/users', usersController.signUp);
    app.delete('/sessions', usersController.logout);
  } else {
    console.warn(unsupportedMessage('users routes'));
  }

  if (passportConfig && passportConfig.google) {
    // google auth
    // Redirect the user to Google for authentication. When complete, Google
    // will redirect the user back to the application at
    // /auth/google/return
    // Authentication with google requires an additional scope param, for more info go
    // here https://developers.google.com/identity/protocols/OpenIDConnect#scope-param
    app.get('/auth/google', passport.authenticate('google', {
      scope: [
        'https://www.googleapis.com/auth/userinfo.profile',
        'https://www.googleapis.com/auth/userinfo.email'
      ]
    }));

    // Google will redirect the user to this URL after authentication. Finish the
    // process by verifying the assertion. If valid, the user will be logged in.
    // Otherwise, the authentication has failed.
    app.get('/auth/google/callback',
      passport.authenticate('google', {
        successRedirect: '/',
        failureRedirect: '/login'
      })
    );
  }

  // topic routes
  if (topicsController) {
    app.get('/topic', topicsController.all);
    app.post('/topic/:id', topicsController.add);
    app.put('/topic/:id', topicsController.update);
    app.delete('/topic/:id', topicsController.remove);
  } else {
    console.warn(unsupportedMessage('topics routes'));
  }
};


text:
package com.example.constructorinjection;

import com.example.ExampleApplicationCI;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ExampleApplicationCI.class)
public class TestCakeClassConstructorInjection {

	@Autowired
	private Cake cake;

	@Test
	public void testConstructorInjection() {
		System.out.println(cake.toString());
		Assert.assertNotNull(cake.getFlavor());
	}
}


text:
namespace dotless.Test.Config
{
    using System.Xml;
    using NUnit.Framework;
    using Core.configuration;
    using System;
    using System.Configuration;

    public class XmlConfigurationFixture
    {
        [Test]
        public void CheckSessionMode()
        {
            Assert.That(LoadConfig(@"<dotless sessionMode=""enabled""/>").SessionMode, Is.EqualTo(DotlessSessionStateMode.Enabled));
            Assert.That(LoadConfig(@"<dotless />").SessionMode, Is.EqualTo(DotlessSessionStateMode.Disabled));
            Assert.That(LoadConfig(@"<dotless sessionMode=""QueryParam""/>").SessionMode, Is.EqualTo(DotlessSessionStateMode.QueryParam));
        }

        [Test]
        public void DefaultHttpExpiryInMinutes()
        {
            Assert.That(LoadConfig(@"<dotless />").HttpExpiryInMinutes, Is.EqualTo(DotlessConfiguration.DefaultHttpExpiryInMinutes));
        }

        [Test]
        public void CustomHttpExpiryInMinutes()
        {
            Assert.That(LoadConfig(@"<dotless httpExpiryInMinutes=""5""/>").HttpExpiryInMinutes, Is.EqualTo(5));
        }

        [Test]
        public void ShouldThrowOnEmptySessionParamName()
        {
            Assert.Throws<ConfigurationErrorsException>(()=> LoadConfig(@"<dotless sessionMode=""queryParam"" sessionQueryParamName=""""/>"));
        }

        private DotlessConfiguration LoadConfig(string xml)
        {
            var interpreter = new XmlConfigurationInterpreter();
            var doc = new XmlDocument();
            doc.LoadXml(xml);
            return interpreter.Process(doc.DocumentElement);
        }
    }
}


text:
slug: 'Skinny Dipping: Mikong Delta'
title: 'Skinny Dipping: Mikong Delta'
#alt-title: It's awesome!
description: This is some description text. It shouln't be longer than 50 words to avoid overkill.
author: Jordan Rancie
categories: ['Travel', 'Asia', 'Vietnam']
tags: ['Most Popular', 'Featured' ]
comments: true
#video-html5:
#  image: videos/lasvegas-poster.jpg
#  mp4: videos/lasvegas.mp4
#  webm: videos/lasvegas.webm
#  height: 600px
#video-embedded:
#  url: ''
#  related: true
# Image types: fullwidth, large, feature, thumbnail
images:
#  - type: fullwidth
#    url: w1.jpg
#    title: This is a test title
#    height: 150px
#  - type: large
#    url: w1.jpg
#    title: This is a test title
#    height: 150px
#  - type: feature
#    url: w1.jpg
#    title: This is a test title
#    height: 150px
  - type: thumbnail
    url: p1.jpg
    title: This is a test title

# Gallery types: fullwidth, large, feature
gallery:
  sitegallery: audreyjordan
  type: large
  thumb: thumb
  related: width330
---

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Ab adipisci architecto consequatur debitis eos eum hic illum ipsam itaque laborum magni minima molestias nostrum numquam odit officia pariatur
                                        perspiciatis placeat porro quae rem, sequi sit soluta temporibus ullam voluptas voluptates. Aliquid amet architecto culpa cumque eius enim esse eum eveniet ex, fugiat illo ipsum laudantium, minima nemo porro sequi
                                        tempora veritatis vero voluptate, voluptatem. Culpa ducimus est eveniet, iste iusto officiis quas repudiandae rerum sit tenetur totam voluptas? Accusamus accusantium alias aliquam aliquid animi commodi dignissimos
                                        dolore doloremque dolorum exercitationem fugiat illum, iste laboriosam maiores molestiae nam odio officia officiis omnis optio placeat quaerat quia quibusdam quis quo ratione sapiente sed sequi sit tenetur unde
                                        ut veniam voluptas! Dicta, voluptatum!

Lid est laborum dolo rumes fugats untras. Etharums ser quidem rerum facilis dolores nemis omnis fugats vitaes nemo minima rerums unsers sadips amets.. Sed ut perspiciatis unde omnis iste natus error

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Adipisci at debitis deleniti dignissimos ea enim iste laboriosam nihil omnis possimus quia, tempora, totam voluptatibus! Animi consectetur dolor in laboriosam
                                        unde.

.blog-classic {
    margin-bottom: 70px;
    padding-bottom: 70px;
    border-bottom: 1px solid #efefef;
}

Lid est laborum dolo rumes fugats untras. Etharums ser quidem rerum facilis dolores nemis omnis fugats vitaes nemo minima rerums unsers sadips amets.. Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium
                                        doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.


text:
#ifndef _IN_GASNET_H
  #error This file is not meant to be included directly- clients should include gasnet.h
#endif

#ifndef _GASNET_EXTENDED_FWD_H
#define _GASNET_EXTENDED_FWD_H

#define GASNET_EXTENDED_VERSION      1.0
#define GASNET_EXTENDED_VERSION_STR  _STRINGIFY(GASNET_EXTENDED_VERSION)
#define GASNET_EXTENDED_NAME         PAMI
#define GASNET_EXTENDED_NAME_STR     _STRINGIFY(GASNET_EXTENDED_NAME)

/* Addition(s) to barrier-types enum: */
#define GASNETE_COLL_CONDUIT_BARRIERS \
	GASNETE_COLL_BARRIER_PAMIALLREDUCE, \
	GASNETE_COLL_BARRIER_PAMIDISSEM

/* Hooks for conduit-specific collectives */
#if !defined(GASNET_NO_PAMI_COLL)
  /* NOTE: Focus is on blocking collectives because they are simpler, and are all that UPCR uses */
  #define GASNET_PAMI_NATIVE_COLL 1
  #define gasnete_coll_init_conduit gasnete_coll_init_pami
  #define gasnete_coll_team_init_conduit gasnete_coll_team_init_pami

  #define gasnete_coll_broadcast  gasnete_coll_broadcast_pami
  #define gasnete_coll_broadcastM gasnete_coll_broadcastM_pami

  #define gasnete_coll_exchange   gasnete_coll_exchange_pami
  #define gasnete_coll_exchangeM  gasnete_coll_exchangeM_pami

  #define gasnete_coll_gather     gasnete_coll_gather_pami
  #define gasnete_coll_gatherM    gasnete_coll_gatherM_pami

  #define gasnete_coll_gather_all  gasnete_coll_gather_all_pami
  #define gasnete_coll_gather_allM gasnete_coll_gather_allM_pami

  #define gasnete_coll_scatter    gasnete_coll_scatter_pami
  #define gasnete_coll_scatterM   gasnete_coll_scatterM_pami

  #if GASNET_PAR
    #define GASNETE_COLL_TEAM_EXTRA struct {  \
        /* collective geom & algorithms: */   \
        pami_geometry_t geom;                 \
        pami_algorithm_t allga_alg;           \
        pami_algorithm_t allto_alg;           \
        pami_algorithm_t bcast_alg;           \
        pami_algorithm_t gathr_alg;           \
        pami_algorithm_t scatt_alg;           \
        pami_algorithm_t allgavi_alg;         \
        pami_algorithm_t alltovi_alg;         \
        pami_algorithm_t gathrvi_alg;         \
        pami_algorithm_t scattvi_alg;         \
        /* for multi-image intermediates: */  \
        size_t scratch_max_nbytes;            \
        size_t scratch_max_nbytes_allto;      \
        void * scratch_space;                 \
        int * counts;                         \
        int * displs;                         \
        size_t prev_nbytes;                   \
        /* for syncronization: */             \
        void * volatile tmp_addr;             \
        volatile int barrier_phase;           \
        char _pad[GASNETI_CACHE_LINE_BYTES];  \
        gasneti_atomic_t barrier_counter[2];  \
    } pami;
  #else
    #define GASNETE_COLL_TEAM_EXTRA struct {  \
        pami_geometry_t geom;                 \
        pami_algorithm_t allga_alg;           \
        pami_algorithm_t allto_alg;           \
        pami_algorithm_t bcast_alg;           \
        pami_algorithm_t gathr_alg;           \
        pami_algorithm_t scatt_alg;           \
    } pami;
  #endif
#endif

#define _GASNET_HANDLE_T
/*  an opaque type representing a non-blocking operation in-progress initiated using the extended API */
struct _gasnete_op_t;
typedef struct _gasnete_op_t *gasnet_handle_t;
#define GASNET_INVALID_HANDLE ((gasnet_handle_t)0)
#define GASNETI_EOP_IS_HANDLE 1

  /* if conduit-internal threads may call the Extended API and/or they may run
     progress functions, then define GASNETE_CONDUIT_THREADS_USING_TD to the
     maximum COUNT of such threads to allocate space for their threaddata
   */
#if 0
  #define GASNETE_CONDUIT_THREADS_USING_TD ###
#endif

  /* this can be used to add statistical collection values
     specific to the extended API implementation (see gasnet_help.h) */
#define GASNETE_CONDUIT_STATS(CNT,VAL,TIME)  \
        GASNETI_VIS_STATS(CNT,VAL,TIME)      \
        GASNETI_COLL_STATS(CNT,VAL,TIME)     \
        CNT(C, DYNAMIC_THREADLOOKUP, cnt)

#define GASNETE_AUXSEG_DECLS \
    extern gasneti_auxseg_request_t gasnete_barr_auxseg_alloc(gasnet_seginfo_t *auxseg_info);
#define GASNETE_AUXSEG_FNS() gasnete_barr_auxseg_alloc,

/*
 * When implementing a conduit-specific implementation of the Extended API, one
 * can #define the following to 1 to change certain behaviors in gasnet_extended.h.
 * Alternatively, one can #define GASNETE_HAVE_EXTENDED_HELP_EXTRA_H and defined
 * these in a conduit-specific gasnet_extended_help_extra.h.
 *
 * GASNETI_DIRECT_GET_NB
 *   unset: gasnete_get_nb() maps to gasnete_get_nb_bulk()
 *   set: conduit provides it own gasnete_get_nb()
 *
 * GASNETI_DIRECT_GET_NBI
 *   unset: gasnete_get_nbi() maps to gasnete_get_nbi_bulk()
 *   set: conduit provides it own gasnete_get_nbi()
 *
 * GASNETI_DIRECT_WAIT_SYNCNB
 *   unset: gasnete_wait_syncnb(h) via gasneti_pollwhile(gasnete_try_syncnb(h))
 *   set: conduit provides it own gasnete_wait_syncnb()
 *
 * GASNETI_DIRECT_WAIT_SYNCNB_SOME
 *   unset: gasnete_wait_syncnb_some(...) via gasneti_pollwhile(gasnete_try_syncnb_some(...))
 *   set: conduit provides it own gasnete_wait_syncnb_some()
 *
 * GASNETI_DIRECT_WAIT_SYNCNB_ALL
 *   unset: gasnete_wait_syncnb_all(...) via gasneti_pollwhile(gasnete_try_syncnb_all(...))
 *   set: conduit provides it own gasnete_wait_syncnb_all()
 *
 * GASNETI_DIRECT_TRY_SYNCNBI_ALL
 *   unset: gasnete_try_syncnbi_all() via calls to gasnete_try_syncnbi_{gets,puts}()
 *   set: conduit provides it own gasnete_try_syncnbi_all()
 *
 * GASNETI_DIRECT_WAIT_SYNCNBI_GETS
 *   unset: gasneti_wait_syncnbi_gets() via gasneti_pollwhile(gasnete_try_syncnbi_gets())
 *   set: conduit provides it own gasneti_wait_syncnbi_gets()
 *
 * GASNETI_DIRECT_WAIT_SYNCNBI_PUTS
 *   unset: gasneti_wait_syncnbi_puts() via gasneti_pollwhile(gasnete_try_syncnbi_puts())
 *   set: conduit provides it own gasneti_wait_syncnbi_puts()
 *
 * GASNETI_DIRECT_WAIT_SYNCNBI_ALL
 *   unset: gasnete_wait_syncnbi_all() via gasneti_pollwhile(gasnete_try_syncnbi_{gets,puts}())
 *   set: conduit provides it own gasneti_wait_syncnbi_all()
 *
 * GASNETI_DIRECT_GET
 *   unset: gasnete_get() maps to gasnete_get_bulk()
 *   set: conduit provides it own gasnete_get()
 *
 * GASNETI_DIRECT_PUT
 *   unset: gasnete_put() maps to gasnete_put_bulk()
 *   set: conduit provides it own gasnete_put()
 *
 * GASNETI_DIRECT_PUT_BULK
 *   unset: gasnete_put_bulk() via gasnete_wait_syncnb(gasnete_put_nb_bulk())
 *   set: conduit provides it own gasnete_put_bulk()
 *
 * GASNETI_DIRECT_MEMSET
 *   unset: gasnete_memset() via gasnete_wait_syncnb(gasnete_memset_nb())
 *   set: conduit provides it own gasnete_memset()
 *
 * GASNETI_DIRECT_PUT_VAL
 *   unset: gasnete_put_val() via gasnete_putTI()
 *   set: conduit provides it own gasnete_put_val()
 *
 * GASNETI_DIRECT_PUT_NB_VAL
 *   unset: extern gasnete_put_nb_val() in gasnet_extended.c (or a macro)
 *   set: conduit provides own gasnete_put_nb_val() as an inline
 *
 * GASNETI_DIRECT_PUT_NBI_VAL
 *   unset: gasnete_put_nbi_val() via gasnete_put_nbi()
 *   set: conduit provides own gasnete_put_nbi_val()
 *
 * GASNETI_DIRECT_GET_VAL
 *   unset: extern gasnete_get_val() in gasnet_extended.c (or a macro)
 *   set: conduit provides own gasnete_get_val() as an inline
 */

/* The following using an ON-STACK eop to avoid alloc/free overheads: */
#define GASNETI_DIRECT_GET_BULK 1
#define GASNETI_DIRECT_PUT_BULK 1

#endif


text:
package nl.han.ica.ap.purify.module.java.magicnumber;

import java.util.ArrayList;
import java.util.List;

import nl.han.ica.ap.purify.language.java.JavaParser.ClassBodyContext;
import nl.han.ica.ap.purify.language.java.JavaParser.LiteralContext;

/**
 * Stores magic number detections.
 *
 * @author Arjan
 */
public class MagicNumber {
	private String literal;
	private ClassBodyContext classBodyContext;
	private List<LiteralContext> contexts;

	public MagicNumber(String literal, ClassBodyContext classBody) {
		if (literal == null || classBody == null) {
			throw new NullPointerException();
		}

		this.literal = literal;
		this.classBodyContext = classBody;
		this.contexts = new ArrayList<LiteralContext>();
	}

	/**
	 * Get the literal.
	 *
	 * @return Literal.
	 */
	public String getLiteral() {
		return this.literal;
	}

	/**
	 * Get method body context
	 *
	 * @return Class body context.
	 */
	public ClassBodyContext getClassBodyContext() {
		return this.classBodyContext;
	}

	/**
	 * Add a literal to the context.
	 *
	 * @param context LIteralContext to add.
	 */
	public void addLiteral(LiteralContext context) {
		if (context == null) {
			throw new NullPointerException();
		}

		this.contexts.add(context);
	}

	/**
	 * Get the context at the index.
	 *
	 * @param index Index of the item.
	 * @return Context at the index.
	 */
	public LiteralContext getContext(int index) {
		return this.contexts.get(index);
	}

	/**
	 * Get the number of detections.
	 *
	 * @return Number of detections.
	 */
	public int size() {
		return this.contexts.size();
	}
}


text:
#include "mitkAffineImageCropperInteractor.h"

#include "mitkInteractionConst.h"
#include "mitkInteractionPositionEvent.h"
#include "mitkRotationOperation.h"
#include "mitkSurface.h"
#include "mitkVtkMapper.h"

#include <mitkBoundingObject.h>
#include <mitkMouseWheelEvent.h>
#include <vtkCamera.h>
#include <vtkInteractorStyle.h>
#include <vtkMatrix4x4.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkRenderWindowInteractor.h>

#include <mitkRotationOperation.h>
#include <mitkScaleOperation.h>

mitk::AffineImageCropperInteractor::AffineImageCropperInteractor()
{
  m_OriginalGeometry = Geometry3D::New();
}

mitk::AffineImageCropperInteractor::~AffineImageCropperInteractor()
{
}

void mitk::AffineImageCropperInteractor::ConnectActionsAndFunctions()
{
  // **Conditions** that can be used in the state machine, to ensure that certain conditions are met, before actually
  // executing an action
  CONNECT_CONDITION("isOverObject", CheckOverObject);

  // **Function** in the statmachine patterns also referred to as **Actions**
  CONNECT_FUNCTION("selectObject", SelectObject);
  CONNECT_FUNCTION("deselectObject", DeselectObject);
  CONNECT_FUNCTION("initTranslate", InitTranslate);
  CONNECT_FUNCTION("initRotate", InitRotate);
  CONNECT_FUNCTION("initDeformation", InitDeformation);
  CONNECT_FUNCTION("translateObject", TranslateObject);
  CONNECT_FUNCTION("rotateObject", RotateObject);
  CONNECT_FUNCTION("deformObject", DeformObject);
  CONNECT_FUNCTION("scaleRadius", ScaleRadius);
}

void mitk::AffineImageCropperInteractor::DataNodeChanged()
{
}

bool mitk::AffineImageCropperInteractor::CheckOverObject(const InteractionEvent *interactionEvent)
{
  mitk::DataNode::Pointer dn = this->GetDataNode();
  if (dn.IsNull())
    return false;
  const InteractionPositionEvent *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
  Point3D currentPickedPoint = positionEvent->GetPositionInWorld();
  mitk::BoundingObject *object = dynamic_cast<mitk::BoundingObject *>(dn->GetData());
  object->GetGeometry()->WorldToIndex(currentPickedPoint, currentPickedPoint);
  return object && object->GetGeometry()->GetBoundingBox()->IsInside(currentPickedPoint);
}

void mitk::AffineImageCropperInteractor::SelectObject(StateMachineAction *, InteractionEvent *interactionEvent)
{
  mitk::DataNode::Pointer dn = this->GetDataNode();

  if (dn.IsNull())
    return;

  m_SelectedNode = dn;

  interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}

void mitk::AffineImageCropperInteractor::Deselect()
{
  mitk::DataNode::Pointer dn = this->GetDataNode();

  if (dn.IsNull())
    return;

  m_SelectedNode = dn;
}

void mitk::AffineImageCropperInteractor::DeselectObject(StateMachineAction *, InteractionEvent *interactionEvent)
{
  Deselect();
  interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}

void mitk::AffineImageCropperInteractor::ScaleRadius(StateMachineAction *, InteractionEvent *interactionEvent)
{
  const MouseWheelEvent *wheelEvent = dynamic_cast<const MouseWheelEvent *>(interactionEvent);
  if (wheelEvent == NULL)
    return;

  if (m_SelectedNode.IsNull())
    return;

  double scale = (double)(wheelEvent->GetWheelDelta()) / 64.0;
  mitk::Point3D newScale;
  newScale[0] = newScale[1] = newScale[2] = scale;

  mitk::Point3D anchorPoint = wheelEvent->GetPositionInWorld();
  ScaleOperation *doOp = new mitk::ScaleOperation(OpSCALE, newScale, anchorPoint);
  m_SelectedNode->GetData()->GetGeometry()->ExecuteOperation(doOp);

  interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}

void mitk::AffineImageCropperInteractor::InitTranslate(StateMachineAction *, InteractionEvent *interactionEvent)
{
  if (m_SelectedNode.IsNull())
    return;
  InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
  if (positionEvent == NULL)
    return;

  m_InitialPickedPoint = positionEvent->GetPositionInWorld();
  m_InitialPickedDisplayPoint = positionEvent->GetPointerPositionOnScreen();

  mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface *>(m_SelectedNode->GetData());
  mitk::BaseGeometry::Pointer surGeo = surface->GetGeometry();
  m_InitialOrigin = surGeo->GetOrigin();
}

void mitk::AffineImageCropperInteractor::InitRotate(StateMachineAction *, InteractionEvent *interactionEvent)
{
  InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
  if (positionEvent == NULL)
    return;

  m_InitialPickedPoint = positionEvent->GetPositionInWorld();
  m_InitialPickedDisplayPoint = positionEvent->GetPointerPositionOnScreen();

  mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface *>(m_SelectedNode->GetData());
  mitk::BaseGeometry::Pointer surGeo = surface->GetGeometry();
  m_OriginalGeometry = dynamic_cast<mitk::Geometry3D *>(surGeo.GetPointer());
}

void mitk::AffineImageCropperInteractor::InitDeformation(StateMachineAction *, InteractionEvent *interactionEvent)
{
  InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
  if (positionEvent == NULL)
    return;

  m_InitialPickedPoint = positionEvent->GetPositionInWorld();
  m_InitialPickedDisplayPoint = positionEvent->GetPointerPositionOnScreen();

  mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface *>(m_SelectedNode->GetData());
  mitk::BaseGeometry::Pointer surGeo = surface->GetGeometry();
  m_OriginalGeometry = dynamic_cast<mitk::Geometry3D *>(surGeo.GetPointer());
}

void mitk::AffineImageCropperInteractor::TranslateObject(StateMachineAction *, InteractionEvent *interactionEvent)
{
  InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
  if (positionEvent == NULL)
    return;

  Point3D currentPickedPoint = positionEvent->GetPositionInWorld();

  Vector3D interactionMove;
  interactionMove[0] = currentPickedPoint[0] - m_InitialPickedPoint[0];
  interactionMove[1] = currentPickedPoint[1] - m_InitialPickedPoint[1];
  interactionMove[2] = currentPickedPoint[2] - m_InitialPickedPoint[2];

  mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface *>(m_SelectedNode->GetData());
  mitk::BaseGeometry::Pointer surGeo = surface->GetGeometry();
  surGeo->SetOrigin(m_InitialOrigin);
  surGeo->Translate(interactionMove);

  interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}

void mitk::AffineImageCropperInteractor::DeformObject(StateMachineAction *, InteractionEvent *interactionEvent)
{
  InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
  if (positionEvent == NULL)
    return;

  Point3D currentPickedPoint = positionEvent->GetPositionInWorld();
  Vector3D interactionMove = currentPickedPoint - m_InitialPickedPoint;

  mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface *>(m_SelectedNode->GetData());
  surface->SetGeometry(m_OriginalGeometry);
  mitk::BaseGeometry::Pointer surGeo = surface->GetGeometry();

  surGeo->WorldToIndex(interactionMove, interactionMove);
  Point3D scale;
  for (int i = 0; i < 3; ++i)
  {
    scale[i] = (interactionMove[i] * surGeo->GetMatrixColumn(i).magnitude()) - 1;
  }

  mitk::Point3D anchorPoint = surGeo->GetCenter();

  ScaleOperation *doOp = new mitk::ScaleOperation(OpSCALE, scale, anchorPoint);
  surGeo->ExecuteOperation(doOp);

  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}

void mitk::AffineImageCropperInteractor::RotateObject(StateMachineAction *, InteractionEvent *interactionEvent)
{
  InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
  if (positionEvent == NULL)
    return;

  Point2D currentPickedDisplayPoint = positionEvent->GetPointerPositionOnScreen();
  if (currentPickedDisplayPoint.EuclideanDistanceTo(m_InitialPickedDisplayPoint) < 1)
    return;

  vtkRenderer *currentVtkRenderer = interactionEvent->GetSender()->GetVtkRenderer();

  if (currentVtkRenderer && currentVtkRenderer->GetActiveCamera())
  {
    double vpn[3];
    currentVtkRenderer->GetActiveCamera()->GetViewPlaneNormal(vpn);

    Vector3D rotationAxis;
    rotationAxis[0] = vpn[0];
    rotationAxis[1] = vpn[1];
    rotationAxis[2] = vpn[2];
    rotationAxis.Normalize();

    Vector2D move = currentPickedDisplayPoint - m_InitialPickedDisplayPoint;

    double rotationAngle = -57.3 * atan(move[0] / move[1]);
    if (move[1] < 0)
      rotationAngle += 180;

    // Use center of data bounding box as center of rotation
    Point3D rotationCenter = m_OriginalGeometry->GetCenter();
    if (positionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
      rotationCenter = m_InitialPickedPoint;

    // Reset current Geometry3D to original state (pre-interaction) and
    // apply rotation
    RotationOperation op(OpROTATE, rotationCenter, rotationAxis, rotationAngle);
    Geometry3D::Pointer newGeometry = static_cast<Geometry3D *>(m_OriginalGeometry->Clone().GetPointer());
    newGeometry->ExecuteOperation(&op);
    m_SelectedNode->GetData()->SetGeometry(newGeometry);

    interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
  }
}


text:
/// Copyright (c) 2012 Ecma International.  All rights reserved.
/// Ecma International makes this code available under the terms and conditions set
/// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the
/// "Use Terms").   Any redistribution of this code must retain the above
/// copyright and this notice and otherwise comply with the Use Terms.
/**
 * @path ch15/15.2/15.2.3/15.2.3.7/15.2.3.7-6-a-211.js
 * @description Object.defineProperties - 'O' is an Array, 'name' is an array index property, both the [[Value]] field of 'desc' and the [[Value]] attribute value of 'name' are null  (15.4.5.1 step 4.c)
 */

function testcase() {
        var arr = [];

        Object.defineProperty(arr, "0", {
            value: null
        });

        Object.defineProperties(arr, {
            "0": {
                value: null
            }
        });
        return dataPropertyAttributesAreCorrect(arr, "0", null, false, false, false);
    }
runTestCase(testcase);