text:
#
# DESCRIPTORS
#

@inproceedings
{
	sift,
	author = {D. G. Lowe},
	title = {{Object recognition from local scale-invariant features}},
	booktitle = {ICCV},
	year = 1999
}

@inproceedings
{
	surf,
	author = {H. Bay and T. Tuytelaars and L. Van Gool},
	title = {{{SURF}: Speeded Up Robust Features}},
	booktitle = {ECCV},
	year = 2006
}

@inproceedings
{
	winder,
	author = {S. Winder   and   M. Brown},
	title = {{Learning   local   image   descriptors}},
	booktitle = {CVPR},
	year = 2007
}

@article
{
	lbpdesc,
	author = {M. Heikkil\"a and M. Pietik\"ainen and C. Schmid},
	title = {{Description of interest regions with local binary patterns}},
	journal = {Pattern Recognition},
	year = 2009
}

@inproceedings
{
	brief,
	author = {M. Calonder and V. Lepetit and C. Strecha and P. Fua},
	title = {{{BRIEF}: Binary Robust Independent Elementary Features}},
	booktitle = {ECCV},
	year = 2010
}

@inproceedings
{
	orb,
	author = {E. Rublee and V. Rabaud and K. Konolige and G. R. Bradski},
	title = {{{ORB}: An efficient alternative to SIFT or SURF}},
	booktitle = {ICCV},
	year = 2011
}

@inproceedings
{
	brisk,
	author = {S. Leutenegger and M. Chli and R. Y. Siegwart},
	title = {{{BRISK}: Binary Robust Invariant Scalable Keypoints}},
	booktitle = {ICCV},
	year = 2011
}

@article
{
	brown,
	author = {M. Brown and G. Hua and S. Winder},
	title = {{Discriminative Learning of Local Image Descriptors}},
	journal = {PAMI},
	year = 2011
}

@inproceedings
{
	cvx,
	author = {K. Simonyan and A. Vedaldi and A. Zisserman},
	title = {{Learning Local Feature Descriptors Using Convex Optimisation}},
	booktitle = {ECCV},
	year = 2012
}

@inproceedings
{
	freak,
	author = {A. Alahi and R. Ortiz and P. Vandergheynst},
	title = {{{FREAK}: Fast Retina Keypoint}},
	booktitle = {CVPR},
	year = 2012
}

@inproceedings
{
	dbrief,
	author = {T. Trzcinski and V. Lepetit},
	title = {{Efficient Discriminative Projections for Compact Binary Descriptors}},
	booktitle = {ECCV},
	year = 2012
}

@inproceedings
{
	boostingtrick,
	author = {T. Trzcinski and M. Christoudias and V. Lepetit and P. Fua},
	title = {{Learning Image Descriptors with the Boosting-Trick}},
	booktitle = {NIPS},
	year = 2012
}

@inproceedings
{
	binboost,
	author = {T. Trzcinski and M. Christoudias and V. Lepetit and P. Fua},
	title = {{Boosting Binary Keypoint Descriptors}},
	booktitle = {CVPR},
	year = 2013
}

@article
{
	ldb,
	author = {X. Yang and K.-T. Cheng},
	title = {{Local Difference Binary for Ultra-fast and Distinctive Feature Description}},
	journal = {PAMI},
	year = 2014
}

@article
{
	rfd,
	author = {B. Fan and Q. Kong and T. Trzcinski and Z. Wang and C. Pan and P. Fua},
	title = {{Receptive Fields Selection for Binary Feature Description}},
	journal = {IEEE Transaction on Image Processing},
	year = 2014
}

@article
{
	localfacerec,
	author = {Z. Li and D. Gong and X. Li and D. Tao},
	title = {{Learning Compact Feature Descriptor and Adaptive Matching Framework for Face Recognition}},
	journal = {IEEE Transaction on Image Processing},
	year = 2015
}

@inproceedings
{
	hpatches,
	author =  {V. Balntas and K. Lenc and A. Vedaldi and K. Mikolajczyk},
	title = {{HPatches: A benchmark and evaluation of handcrafted and learned local descriptors}},
	booktitle = {CVPR},
	year = 2017
}

#
# ANN DESCRIPTORS
#

@inproceedings
{
	osendorfer,
	author = {C. Osendorfer and J. Bayer and S. Urban and P. van der Smagt},
	title = {{Convolutional Neural Networks Learn Compact Local Image Descriptors}},
	booktitle = {ICONIP (2)},
	year = {2013}
}

@misc
{
	fracking,
	author = {E. Simo-Serra and E. Trulls and L. Ferraz and I. Kokkinos and F. Moreno-Noguer},
	title = {{Fracking Deep Convolutional Image Descriptors}},
	year = {2015},
	howpublished = {\url{http://arxiv.org/abs/1412.6537}}
}

@inproceedings
{
	zagoruyko,
	author =  {S. Zagoruyko and N. Komodakis},
	title = {{Learning to Compare Image Patches via Convolutional Neural Networks}},
	booktitle = {CVPR},
	year = 2015
}

@inproceedings
{
	matchnet,
	author = {X. Han and T. Leung and Y. Jia and R. Sukthankar and A. C. Berg},
	booktitle = {CVPR},
	title = {{MatchNet: Unifying Feature and Metric Learning for Patch-Based Matching}},
	year = {2015}
}

@inproceedings
{
	convdesc,
	author = {E. Simo-Serra and E. Trulls and L. Ferraz and I. Kokkinos and P. Fua and F. Moreno-Noguer},
	booktitle = {ICCV},
	title = {{Discriminative Learning of Deep Convolutional Feature Point Descriptors}},
	year = {2015}
}

@misc
{
	pnnet,
	author = {V. Balntas and E. Johns and L. Tang and K. Mikolajczyk},
	title = {{PN-Net: Conjoined Triple Deep Network for Learning Local Image Descriptors}},
	howpublished = {\url{http://arxiv.org/abs/1601.05030}},
	eprint = {arXiv:1601.05030}
}

@inproceedings
{
	convcorr,
	author = {J. L. Long and N. Zhang and Trevor Darrell},
	title = {{Do Convnets Learn Correspondence?}},
	booktitle = {NIPS},
	year = {2014}
}

@inproceedings
{
	kernelconv0,
    title = {{Convolutional kernel networks}},
    author = {J. Mairal and P. Koniusz and Z. Harchaoui and C. Schmid},
    year = {2014},
    booktitle = {NIPS}
}

@inproceedings
{
	kernelconv,
    title={{Local Convolutional Features with Unsupervised Training for Image Retrieval}},
    author = {M. Paulin and M. Douze and Z. Harchaoui and J. Mairal and F. Perronnin and C. Schmid},
    year={2015},
    booktitle = {ICCV}
}

@techreport
{
	wlrn,
	author = {Nenad Markus},
	title = {{Learning Local Descriptors from Weakly-Labeled Data}},
	institution  = {University of Zagreb, Faculty of Electrical Engineering and Computing},
	address = {Unska 3, 10000 Zagreb},
	year = {2016},
	note = {\url{https://github.com/nenadmarkus/wlrn}}
}

@inproceedings
{
	netvlad,
	author = {R. Arandjelovi\'c and P. Gronat and A. Torii and T. Pajdla and J. Sivic},
	title = {{NetVLAD: CNN architecture for weakly supervised place recognition}},
	booktitle = {CVPR},
	year = {2016}
}

@inproceedings
{
	tfeat,
	author = {V. Balntas and E. Riba and D. Ponsa and K. Mikolajczyk},
	title = {Learning local feature descriptors with triplets and shallow convolutional neural networks},
	booktitle = {BMVC},
	year = {2016}
}

#
# DATASETS
#

@inproceedings
{
	ukb,
	author = {D. Nist\'er and H. Stew\'enius},
	title = {{Scalable Recognition with a Vocabulary Tree}},
	year = 2006,
	booktitle = {CVPR}
}

@techreport
{
	coil-100,
	author = {S. A. Nene and S. K. Nayar and H. Murase},
	title = {{Columbia Object Image Library (COIL-100)}},
	institution = {Columbia University},
	year = 1996
}

@techreport
{
	zubud,
	author = {H. Shao and T. Svoboda and L. V. Gool},
	title = {{ZuBuD---Z\"urich building database for image based recognition}},
	institution = {ETH Z\"urich},
	year = 2003
}

@inproceedings
{
	holidays,
	author = {H. Jegou and M. Douze and C. Schmid},
	title = {{Hamming embedding and weak geometric consistency for large scale image search}},
	year = 2008,
	booktitle = {ECCV}
}

#
# OTHER
#

@article
{
	MIL,
	author = {T. G. Dietterich and R. H. Lathrop and T. Lozano-Perez},
	title = {{Solving the multiple instance problem with axis-parallel rectangles }},
	journal = {Artificial Intelligence},
	year = 1997
}

@inproceedings
{
	recognisingpanoramas,
	author = {M. Brown and D. G. Lowe},
	title = {{Recognising panoramas}},
	booktitle = {ICCV},
	year = 2003
}

@inproceedings
{
	visualwords,
	author = {G. Csurka and C. Dance and L. Fan and J. Willamowski and C. Bray},
	title = {{Visual categorization with bags of keypoints}},
	booktitle = {ECCV},
	year = 2004
}

@inproceedings
{
	siamesenet,
	author = {R. Hadsell and S. Chopra and Y. LeCun},
	title = {{Dimensionality Reduction by Learning an Invariant Mapping}},
	booktitle = {CVPR},
	year = 2006
}

@inproceedings
{
	FAST,
	author = {E. Rosten and T. Drummond},
	title = {{Machine Learning for High-speed Corner Detection}},
	booktitle = {ECCV},
	year = 2006
}

@inproceedings
{
	multiviewstereo,
	author = {M. Goesele and N. Snavely and B. Curless and H. Hoppe and S. M. Seitz},
	title = {{Multi-View Stereo for Community Photo Collections}},
	booktitle = {ICCV},
	year = 2007
}

@inproceedings
{
	fisherkernel,
	author = {F. Perronnin and J. Sanchez and T. Mensink},
	title = {{Improving the Fisher Kernel for Large-Scale Image Classification}},
	booktitle = {ECCV},
	year = 2010
}

@inproceedings
{
	sdm,
	author = {X. Xiong  and F. De la Torre},
	title = {Supervised descent method and its applications to face alignment},
	booktitle = {CVPR},
	year = {2013}
}

@inproceedings
{
	tilde,
	author = {Y. Verdie and K. M. Yi and P. Fua and V. Lepetit},
	title = {{TILDE: A Temporally Invariant Learned DEtector}},
	booktitle = {CVPR},
	year = 2015
}

@inproceedings
{
	shapefrom2dlandmarks,
	author = {X. Zhou and S. Leonardos and X. Hu and K. Daniilidis},
	title = {{3D Shape Estimation from 2D Landmarks: A Convex Relaxation Approach}},
	booktitle = {CVPR},
	year = 2015
}

@inproceedings
{
	flowweb,
	author = {T. Zhou and Y. J. Lee and S. X. Yu and A. A. Efros},
	title = {{FlowWeb: Joint Image Set Alignment by Weaving Consistent, Pixel-wise Correspondences}},
	booktitle = {CVPR},
	year = 2015
}

@inproceedings
{
	spatialpyr,
	author = {S. Lazebnik and C. Schmid and J. Ponce},
	title = {{Beyond Bags of Features: Spatial Pyramid Matching for Recognizing Natural Scene Categories}},
	booktitle = {CVPR},
	year = 2006
}

@inproceedings
{
	hybridbow,
	author = {P. Papadakis and I. Pratikakis and T. Theoharis and G. Passalis and S. J. Perantonis},
	title = {{3D object retrieval using an efficient and compact hybrid shape descriptor}},
	booktitle = {Eurographics Workshop on 3D Object Retrieval},
	year = 2008
}

@inproceedings
{
	cov3d,
	author = {H. Tabia and H. Laga and D. Picard and P. H. Gosselin},
	title = {{Covariance descriptors for 3D shape matching and retrieval}},
	booktitle = {CVPR},
	year = 2014
}

@article
{
	beyondsp,
	author = {J. S\'{a}ncheza and F. Perronnin and T. de Campos},
	title = {{Modeling the spatial layout of images beyond spatial pyramids}},
	journal = {Pattern Recognition Letters},
	year = 2012
}

@inproceedings
{
	summax,
	author = {C. Wallraven and B. Caputo and A. Graf},
	title = {{Recognition with Local Features: the Kernel Recipe}},
	booktitle = {ICCV},
	year = 2003
}

@inproceedings
{
	fisherfaces,
	author       = {K. Simonyan and O. M. Parkhi and A. Vedaldi and A. Zisserman},
	title        = {{F}isher {V}ector {F}aces in the {W}ild},
	booktitle    = {BMVC},
	year         = 2013,
}

@inproceedings
{
	vlad,
	author = {R. Arandjelovic and A. Zisserman},
	title = {{All About VLAD}},
	booktitle = {CVPR},
	year = 2013
}

repository: nenadmarkus/wlrn

repo_name: nenadmarkus/wlrn


text:
/**
 * Copyright 2020 TryFix Engineering.
 * All rights reserved.
 * Authors:
 *    Gayan Yapa (gmbyapa@gmail.com)
 */

package kstream

import (
	"context"
	"github.com/tryfix/errors"
	"github.com/tryfix/kstream/data"
	"github.com/tryfix/kstream/kstream/encoding"
	"github.com/tryfix/kstream/kstream/processors"
	"github.com/tryfix/kstream/kstream/processors/join"
	"github.com/tryfix/kstream/kstream/store"
	"github.com/tryfix/log"
)

// Starting offset for the global table partition.
type GlobalTableOffset int64

// GlobalTableOffsetDefault defines the starting offset for the GlobalTable when GlobalTable stream syncing started.
const GlobalTableOffsetDefault GlobalTableOffset = 0

// GlobalTableOffsetLatest defines the beginning of the partition.
// Suitable for topics with retention policy delete since the topic can contains historical data.
const GlobalTableOffsetLatest GlobalTableOffset = -1

// globalTableStoreWriter overrides the persistence logic for GlobalTables.
var globalTableStoreWriter = func(r *data.Record, st store.Store) error {
	if _, ok := st.(store.IndexedStore); ok {
		return globalTableIndexedStoreWriter(r, st)
	}
	// tombstone handling
	if r.Value == nil {
		return st.Backend().Delete(r.Key)
	}

	return st.Backend().Set(r.Key, r.Value, 0)
}

var globalTableIndexedStoreWriter = func(r *data.Record, store store.Store) error {
	k, err := store.KeyEncoder().Decode(r.Key)
	if err != nil {
		return errors.WithPrevious(err, `indexable-store-writer key decode error`)
	}
	if r.Value == nil {
		return store.Delete(context.Background(), k)
	}

	v, err := store.ValEncoder().Decode(r.Value)
	if err != nil {
		return errors.WithPrevious(err, `indexable-store-writer value decode error`)
	}

	return store.Set(context.Background(), k, v, 0)
}

type globalTableOptions struct {
	initialOffset           GlobalTableOffset
	logger                  log.Logger
	backendWriter           StoreWriter
	recordVersionExtractor  RecordVersionExtractor
	recordVersionComparator RecordVersionComparator
}

type GlobalTableOption func(options *globalTableOptions)

// GlobalTableWithOffset overrides the default starting offset when GlobalTable syncing started.
func GlobalTableWithOffset(offset GlobalTableOffset) GlobalTableOption {
	return func(options *globalTableOptions) {
		options.initialOffset = offset
	}
}

// GlobalTableWithLogger overrides the default logger for the GlobalTable (default is NoopLogger).
func GlobalTableWithLogger(logger log.Logger) GlobalTableOption {
	return func(options *globalTableOptions) {
		options.logger = logger
	}
}

// GlobalTableWithVersionExtractor adds the version extractor for the GlobalTable from past records (default is nil).
func GlobalTableWithVersionExtractor(extractor RecordVersionExtractor) GlobalTableOption {
	return func(options *globalTableOptions) {
		options.recordVersionExtractor = extractor
	}
}

// GlobalTableWithVersionComparator adds the version extractor for the GlobalTable from past records (default is nil).
func GlobalTableWithVersionComparator(comparator RecordVersionComparator) GlobalTableOption {
	return func(options *globalTableOptions) {
		options.recordVersionComparator = comparator
	}
}

// GlobalTableWithBackendWriter overrides the persisting behavior of the GlobalTable.
// eg :
//	func(r *data.Record, store store.Store) error {
//		// tombstone handling
//		if r.Value == nil {
//			if err := store.Backend().Delete(r.Key); err != nil {
//				return err
//			}
//		}
//
//		return store.Backend().Set(r.Key, r.Value, 0)
//	}
func GlobalTableWithBackendWriter(writer StoreWriter) GlobalTableOption {
	return func(options *globalTableOptions) {
		options.backendWriter = writer
	}
}

type GlobalTable interface {
	Stream
}

type globalKTable struct {
	*kStream
	storeName string
	store     store.Store
	options   *globalTableOptions
}

func (t *globalKTable) To(topic string, keyEncoder encoding.Builder, valEncoder encoding.Builder, options ...SinkOption) {
	panic(`global table dose not support stream processing`)
}

func (t *globalKTable) Transform(transformer processors.TransFunc) Stream {
	panic(`global table dose not support stream transforming`)
}

func (t *globalKTable) Filter(filter processors.FilterFunc) Stream {
	panic(`global table dose not support stream processing`)
}

func (t *globalKTable) Process(processor processors.ProcessFunc) Stream {
	panic(`global table dose not support stream processing`)
}

func (t *globalKTable) Join(stream Stream, keyMapper join.KeyMapper, valMapper join.ValueMapper) Stream {
	panic(`global table to global table joins are not supported yet`)
}

license: MIT

repository: tryfix/kstream

license_type: permissive

repo_name: tryfix/kstream

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: Go

extension: go


text:
@article{RN917,
 author = {Cheng, A. C. and Kotsimbos, T. and Kelly, H. A. and Irving, L. B. and Bowler, S. D. and Brown, S. G. A. and Holmes, M. and Jenkins, C. R. and Thompson, P. and Simpson, G. and Wood-Baker, R. and Senanayake, S. N. and Brady, S. J. and Paterson, D. L. and Wark, P. A. and Upham, J. W. and Korman, T. M. and Dwyer, D. E. and Waterer, G. W. and Kelly, P. M.},
 doi = {10.1016/j.vaccine.2011.07.087},
 journal = {Vaccine},
 number = {43},
 pages = {7320-7325},
 title = {Effectiveness of H1N1/09 monovalent and trivalent influenza vaccines against hospitalization with laboratory-confirmed H1N1/09 influenza in Australia: A test-negative case control study},
 type = {Journal Article},
 url = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-80053437598&doi=10.1016%2fj.vaccine.2011.07.087&partnerID=40&md5=810c31cd37175782fc3a12d876afbe30
http://www.sciencedirect.com/science/article/pii/S0264410X11011376},
 volume = {29},
 year = {2011}
}

extension: bib


text:
SUMMARY = "The GL Vendor-Neutral Dispatch library"

FILESEXTRAPATHS_prepend := "${THISDIR}/files:"

SRC_URI = "https://github.com/NVIDIA/libglvnd/archive/v${PV}.tar.gz;downloadfilename=${BP}.tar.gz \
           file://0000-egl-pkgconfig.patch \
		   file://0001-glvnd-header.patch"
SRC_URI[md5sum] = "390f7934a22a17c9542621b727fc5908"
SRC_URI[sha256sum] = "baca5e1a78b96a112650cdc597be3f856d4754eb73a7bf3f6629e78a7e9f2b5a"

LICENSE = "MIT & BSD"
LIC_FILES_CHKSUM = "file://README.md;beginline=309;md5=f98ec0fbe6c0d2fbbd0298b5d9e664d3"

#S = "${WORKDIR}/${PN}"

DEPENDS = "python libx11 libxext xorgproto"
REQUIRED_DISTRO_FEATURES = "x11 opengl"

inherit autotools pkgconfig

PROVIDES = "virtual/libgl virtual/libgles1 virtual/libgles2 virtual/egl virtual/mesa"
RPROVIDES_${PN} = "libgl libgles1 libgles2 libegl egl xserver-xorg-extension-glx"

do_install_append() {
        mkdir -p ${D}${includedir}
        cp -rf ${S}/include/GL ${D}${includedir}/
        cp -rf ${S}/include/KHR ${D}${includedir}/
        cp -rf ${S}/include/EGL ${D}${includedir}/
        cp -rf ${S}/include/GLES ${D}${includedir}/
		cp -rf ${S}/include/GLES2 ${D}${includedir}/
		cp -rf ${S}/include/GLES3 ${D}${includedir}/
        cp -rf ${S}/include/glvnd ${D}${includedir}/
        cp -rf ${S}/include/glheader.h ${D}${includedir}/

		ln -sf libOpenGL.so.0 ${D}${libdir}/libOpenGL.so
		ln -sf libGLESv1_CM.so.1.2.0 ${D}${libdir}/libGLESv1_CM.so.1
		ln -sf libGLESv1_CM.so.1 ${D}${libdir}/libGLESv1_CM.so
		ln -sf libGLESv2.so.2.1.0 ${D}${libdir}/libGLESv2.so.2
		ln -sf libGLESv2.so.2 ${D}${libdir}/libGLESv2.so
		ln -sf libGLX.so.0 ${D}${libdir}/libGLX.so
		ln -sf libGL.so.1.7.0 ${D}${libdir}/libGL.so.1
		ln -sf libGL.so.1 ${D}${libdir}/libGL.so
		ln -sf libEGL.so.1.1.0 ${D}${libdir}/libEGL.so.1
		ln -sf libEGL.so.1 ${D}${libdir}/libEGL.so
}

FILES_${PN} = " \
	${libdir} \
"

FILES_${PN}-dev = " \
    ${includedir} \
"

INHIBIT_PACKAGE_DEBUG_SPLIT = "1"
INHIBIT_PACKAGE_STRIP = "1"
INSANE_SKIP_${PN}_append = "ldflags already-stripped dev-so"
INSANE_SKIP_libgl-nvidia_append = "ldflags"

extension: bb


text:
package main

import (
	"github.com/EndlessCheng/codeforces-go/main/testutil"
	"testing"
)

// https://codeforces.com/problemset/problem/377/C
// https://codeforces.com/problemset/status/377/problem/C
func TestCF377C(t *testing.T) {
	// just copy from website
	rawText := `
inputCopy
2
2 1
2
p 1
p 2
outputCopy
1
inputCopy
6
6 4 5 4 5 5
4
b 2
p 1
b 1
p 2
outputCopy
0
inputCopy
4
1 2 3 4
4
p 2
b 2
p 1
b 1
outputCopy
-2`
	testutil.AssertEqualCase(t, rawText, 0, CF377C)
}

repository: EndlessCheng/codeforces-go

repo_name: EndlessCheng/codeforces-go


text:
// Copyright 2020 Hal@shurabaP.  All rights reserved.
// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.

package utau

import "os"

// Voicebank represents a single UTAU library.
type Voicebank struct {
	Path string `json:"path"`
	PhonemesMap map[string]*Phonemes `json:"phoneme_sets"`
	Character *Character `json:"character"`
	Affixes   *Affixes   `json:"affixes"`
}

// VoicebankReader reads voicebanks from file on the file system.
type VoicebankReader interface {
	Read(string) (*Voicebank, error)
}

// VoicebankReaderDefault is a default VoicebankReader.
type voicebankReaderDefault struct {
	pr PhonemesReader
	cr CharacterReader
	ar AffixesReader
	de directoryEnumerator
}

// VoicebankReaderDefault is a default VoicebankReader.
func (vr voicebankReaderDefault) Read(path string) (*Voicebank, error) {
	ds, err := vr.de.Enumerate(path)
	if err != nil {
		return nil, err
	}
	pm := map[string]*Phonemes { }
	for _, d := range ds {
		if !d.IsDir() {
			continue
		}
		ps, err := vr.pr.Read(resolvePath(resolvePath(path, d.Name()), "oto.ini"))
		if err == nil {
			pm[d.Name()] = ps
		}
	}
	c, err := vr.cr.Read(resolvePath(path, "character.txt"))
	if err != nil {
		c = &Character{}
	}
	a, err := vr.ar.Read(resolvePath(path, "prefix.map"))
	if err != nil {
		a = &Affixes{}
	}
	return &Voicebank {
		Path: path,
		PhonemesMap: pm,
		Character: c,
		Affixes: a,
	}, nil
}

func resolvePath(path string, filename string) string {
	return path + string(os.PathSeparator) + filename
}


text:
DESCRIPTION = "Unix::Statgrab is a wrapper for libstatgrab as available from \
<http://www.i-scream.org/libstatgrab/>. It is a reasonably portable attempt \
to query interesting stats about your computer. It covers information on \
the operating system, CPU, memory usage, network interfaces, hard-disks \
etc."

SECTION = "libs"
LICENSE = "Artistic-1.0 | GPL-1.0-or-later | LGPL-2.1-only"
PR = "r0"

MAINTAINER=	"Poky <poky@yoctoproject.org>"
HOMEPAGE=	"https://metacpan.org/release/Unix-Statgrab"

LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Artistic-1.0;md5=cda03bbdc3c1951996392b872397b798 \
file://${COMMON_LICENSE_DIR}/GPL-1.0-or-later;md5=30c0b8a5048cc2f4be5ff15ef0d8cf61 \
file://${COMMON_LICENSE_DIR}/LGPL-2.1-only;md5=1a6d268fd218675ffea8be556788b780"

SRC_URI = "https://cpan.metacpan.org/authors/id/R/RE/REHSACK/Unix-Statgrab-0.112.tar.gz"

SRC_URI[md5sum] = "a6bc06b3f7749f7d77a2b1bd13402821"
SRC_URI[sha256sum] = "16a29f7acaeec081bf0e7303ba5ee24fda1d21a1104669b837745f3ea61d6afa"
DEPENDS += "capture-tiny-perl-native"
DEPENDS += "config-autoconf-perl-native"
DEPENDS += "libstatgrab"
RECOMMENDS += "test-leaktrace-perl-native"

S = "${WORKDIR}/Unix-Statgrab-${PV}"

inherit cpan pkgconfig

do_configure() {
	export LD="${CCLD}"
	cpan_do_configure
}

BBCLASSEXTEND = "native"

repository: rehsack/meta-cpan

repo_name: rehsack/meta-cpan

gha_language: BitBake


text:
package main

import (
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"crypto/sha256"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"strconv"

	"github.com/btcsuite/btcutil/base58"
	"golang.org/x/crypto/pbkdf2"

	"github.com/matthewpi/privatebin/utils"
)

const (
	specIterations  = 100000
	specKeySize     = 256
	specTagSize     = 128
	specAlgorithm   = "aes"
	specMode        = "gcm"
	specCompression = "none"
)

// PasteRequest .
type PasteRequest struct {
	V     int              `json:"v"`
	AData []interface{}    `json:"adata"`
	Meta  PasteRequestMeta `json:"meta"`
	CT    string           `json:"ct"`
}

// PasteRequestMeta .
type PasteRequestMeta struct {
	Expire string `json:"expire"`
}

// PasteResponse .
type PasteResponse struct {
	Status      int    `json:"status"`
	ID          string `json:"id"`
	URL         string `json:"url"`
	DeleteToken string `json:"deletetoken"`
}

// PasteContent .
type PasteContent struct {
	Paste string `json:"paste"`
}

// PasteSpec .
type PasteSpec struct {
	IV          string
	Salt        string
	Iterations  int
	KeySize     int
	TagSize     int
	Algorithm   string
	Mode        string
	Compression string
}

// SpecArray .
func (spec *PasteSpec) SpecArray() []interface{} {
	return []interface{}{
		spec.IV,
		spec.Salt,
		spec.Iterations,
		spec.KeySize,
		spec.TagSize,
		spec.Algorithm,
		spec.Mode,
		spec.Compression,
	}
}

// PasteData .
type PasteData struct {
	*PasteSpec
	Data []byte
}

// adata .
func (paste *PasteData) adata() []interface{} {
	return []interface{}{
		paste.SpecArray(),
		"plaintext",
		0,
		0,
	}
}

func main() {
	// Read from STDIN (Piped input)
	input, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		panic(err)
		return
	}

	// Remove extra line breaks to prevent PrivateBin from breaking.
	if bytes.HasSuffix(input, []byte("\n")) {
		input = input[:len(input)-1]
	}

	// Marshal the paste content to escape JSON characters.
	pasteContent, err := json.Marshal(&PasteContent{Paste: utils.StripANSI(string(input))})
	if err != nil {
		panic(err)
		return
	}

	// Generate a master key for the paste.
	masterKey, err := utils.GenRandomBytes(32)
	if err != nil {
		panic(err)
		return
	}

	// Encrypt the paste data
	pasteData, err := encrypt(masterKey, pasteContent)
	if err != nil {
		panic(err)
		return
	}

	// Create a new Paste Request.
	pasteRequest := &PasteRequest{
		V:     2,
		AData: pasteData.adata(),
		Meta: PasteRequestMeta{
			Expire: "1week",
		},
		CT: utils.Base64(pasteData.Data),
	}

	// Get the Request Body.
	body, err := json.Marshal(pasteRequest)
	if err != nil {
		panic(err)
		return
	}

	// Create a new HTTP Client and HTTP Request.
	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://privatebin.net", bytes.NewBuffer(body))
	if err != nil {
		panic(err)
		return
	}

	// Set the request headers.
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Set("Content-Length", strconv.Itoa(len(body)))
	req.Header.Set("X-Requested-With", "JSONHttpRequest")

	// Run the http request.
	res, err := client.Do(req)
	if err != nil {
		panic(err)
		return
	}

	// Close the request body once we are done.
	defer func() {
		if err := res.Body.Close(); err != nil {
			panic(err)
			return
		}
	}()

	// Read the response body.
	response, err := ioutil.ReadAll(res.Body)
	if err != nil {
		panic(err)
		return
	}

	// Decode the response.
	pasteResponse := &PasteResponse{}
	if err := json.Unmarshal(response, &pasteResponse); err != nil {
		panic(err)
		return
	}

	fmt.Printf("%s%s#%s\n", "https://privatebin.net", pasteResponse.URL, base58.Encode(masterKey))
}

func encrypt(master []byte, message []byte) (*PasteData, error) {
	// Generate a initialization vector.
	iv, err := utils.GenRandomBytes(12)
	if err != nil {
		return nil, err
	}

	// Generate salt.
	salt, err := utils.GenRandomBytes(8)
	if err != nil {
		return nil, err
	}

	// Create the Paste Data and generate a key.
	paste := &PasteData{
		PasteSpec: &PasteSpec{
			IV:          utils.Base64(iv),
			Salt:        utils.Base64(salt),
			Iterations:  specIterations,
			KeySize:     specKeySize,
			TagSize:     specTagSize,
			Algorithm:   specAlgorithm,
			Mode:        specMode,
			Compression: specCompression,
		},
	}
	key := pbkdf2.Key(master, salt, paste.Iterations, 32, sha256.New)

	// Get the "adata" for the paste.
	adata, err := json.Marshal(paste.adata())
	if err != nil {
		return nil, err
	}

	// Create a new Cipher
	c, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}

	// Create a new GCM.
	gcm, err := cipher.NewGCM(c)
	if err != nil {
		return nil, err
	}

	// Sign the message.
	data := gcm.Seal(nil, iv, message, adata)

	// Update and return the paste data.
	paste.Data = data

	return paste, nil
}

repository: matthewpi/privatebin

repo_name: matthewpi/privatebin

branch_name: refs/heads/develop


text:
/*
Copyright 2019 The Volcano Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package job

import (
	"context"
	"errors"
	"fmt"
	"github.com/agiledragon/gomonkey/v2"
	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"reflect"
	"testing"

	"volcano.sh/apis/pkg/apis/batch/v1alpha1"
	schedulingapi "volcano.sh/apis/pkg/apis/scheduling/v1beta1"
	"volcano.sh/volcano/pkg/controllers/apis"
	"volcano.sh/volcano/pkg/controllers/job/state"
)

func TestKillJobFunc(t *testing.T) {
	namespace := "test"

	testcases := []struct {
		Name           string
		Job            *v1alpha1.Job
		PodGroup       *schedulingapi.PodGroup
		PodRetainPhase state.PhaseMap
		UpdateStatus   state.UpdateStatusFn
		JobInfo        *apis.JobInfo
		Services       []v1.Service
		ConfigMaps     []v1.ConfigMap
		Secrets        []v1.Secret
		Pods           map[string]*v1.Pod
		Plugins        []string
		ExpectVal      error
	}{
		{
			Name: "KillJob success Case",
			Job: &v1alpha1.Job{
				ObjectMeta: metav1.ObjectMeta{
					Name:            "job1",
					Namespace:       namespace,
					UID:             "e7f18111-1cec-11ea-b688-fa163ec79500",
					ResourceVersion: "100",
				},
			},
			PodGroup: &schedulingapi.PodGroup{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "job1-e7f18111-1cec-11ea-b688-fa163ec79500",
					Namespace: namespace,
				},
			},
			PodRetainPhase: state.PodRetainPhaseNone,
			UpdateStatus:   nil,
			JobInfo: &apis.JobInfo{
				Namespace: namespace,
				Name:      "jobinfo1",
				Pods: map[string]map[string]*v1.Pod{
					"task1": {
						"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
						"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
					},
				},
			},
			Services: []v1.Service{
				{
					ObjectMeta: metav1.ObjectMeta{
						Name:      "job1",
						Namespace: namespace,
					},
				},
			},
			Secrets: []v1.Secret{
				{
					ObjectMeta: metav1.ObjectMeta{
						Name:      "job1-e7f18111-1cec-11ea-b688-fa163ec79500-ssh",
						Namespace: namespace,
					},
				},
			},
			Pods: map[string]*v1.Pod{
				"pod1": buildPod(namespace, "pod1", v1.PodRunning, nil),
				"pod2": buildPod(namespace, "pod2", v1.PodRunning, nil),
			},
			Plugins:   []string{"svc", "ssh", "env"},
			ExpectVal: nil,
		},
	}

	for i, testcase := range testcases {

		t.Run(testcase.Name, func(t *testing.T) {
			fakeController := newFakeController()
			jobPlugins := make(map[string][]string)

			for _, service := range testcase.Services {
				_, err := fakeController.kubeClient.CoreV1().Services(namespace).Create(context.TODO(), &service, metav1.CreateOptions{})
				if err != nil {
					t.Error("Error While Creating Service")
				}
			}

			for _, secret := range testcase.Secrets {
				_, err := fakeController.kubeClient.CoreV1().Secrets(namespace).Create(context.TODO(), &secret, metav1.CreateOptions{})
				if err != nil {
					t.Error("Error While Creating Secret.")
				}
			}

			for _, pod := range testcase.Pods {
				_, err := fakeController.kubeClient.CoreV1().Pods(namespace).Create(context.TODO(), pod, metav1.CreateOptions{})
				if err != nil {
					t.Error("Error While Creating ConfigMaps")
				}
			}

			_, err := fakeController.vcClient.BatchV1alpha1().Jobs(namespace).Create(context.TODO(), testcase.Job, metav1.CreateOptions{})
			if err != nil {
				t.Error("Error While Creating Jobs")
			}
			err = fakeController.cache.Add(testcase.Job)
			if err != nil {
				t.Error("Error While Adding Job in cache")
			}

			for _, plugin := range testcase.Plugins {
				jobPlugins[plugin] = make([]string, 0)
			}

			testcase.JobInfo.Job = testcase.Job
			testcase.JobInfo.Job.Spec.Plugins = jobPlugins

			testcase.JobInfo.Job.Status.ControlledResources = map[string]string{}
			for _, name := range testcase.Plugins {
				testcase.JobInfo.Job.Status.ControlledResources["plugin-"+name] = name
			}

			err = fakeController.killJob(testcase.JobInfo, testcase.PodRetainPhase, testcase.UpdateStatus)
			if err != nil {
				t.Errorf("Case %d (%s): expected: No Error, but got error %v.", i, testcase.Name, err)
			}

			for _, plugin := range testcase.Plugins {

				if plugin == "svc" {
					_, err = fakeController.kubeClient.CoreV1().Services(namespace).Get(context.TODO(), testcase.Job.Name, metav1.GetOptions{})
					if err == nil {
						t.Errorf("Case %d (%s): expected: Service to be deleted, but not deleted.", i, testcase.Name)
					}
				}

				if plugin == "ssh" {
					_, err := fakeController.kubeClient.CoreV1().ConfigMaps(namespace).Get(context.TODO(),
						fmt.Sprintf("%s-%s-%s", testcase.Job.Name, testcase.Job.UID, "ssh"), metav1.GetOptions{})
					if err == nil {
						t.Errorf("Case %d (%s): expected: Secret to be deleted, but not deleted.", i, testcase.Name)
					}
				}
			}
		})
	}
}

func TestSyncJobFunc(t *testing.T) {
	namespace := "test"

	testcases := []struct {
		Name           string
		Job            *v1alpha1.Job
		PodGroup       *schedulingapi.PodGroup
		PodRetainPhase state.PhaseMap
		UpdateStatus   state.UpdateStatusFn
		JobInfo        *apis.JobInfo
		Pods           map[string]*v1.Pod
		Plugins        []string
		TotalNumPods   int
		ExpectVal      error
	}{
		{
			Name: "SyncJob success Case",
			Job: &v1alpha1.Job{
				ObjectMeta: metav1.ObjectMeta{
					Name:            "job1",
					Namespace:       namespace,
					ResourceVersion: "100",
					UID:             "e7f18111-1cec-11ea-b688-fa163ec79500",
				},
				Spec: v1alpha1.JobSpec{
					Tasks: []v1alpha1.TaskSpec{
						{
							Name:     "task1",
							Replicas: 6,
							Template: v1.PodTemplateSpec{
								ObjectMeta: metav1.ObjectMeta{
									Name:      "pods",
									Namespace: namespace,
								},
								Spec: v1.PodSpec{
									Containers: []v1.Container{
										{
											Name: "Containers",
										},
									},
								},
							},
						},
					},
				},
				Status: v1alpha1.JobStatus{
					State: v1alpha1.JobState{
						Phase: v1alpha1.Pending,
					},
				},
			},
			PodGroup: &schedulingapi.PodGroup{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "job1-e7f18111-1cec-11ea-b688-fa163ec79500",
					Namespace: namespace,
				},
				Spec: schedulingapi.PodGroupSpec{
					MinResources:  &v1.ResourceList{},
					MinTaskMember: map[string]int32{},
				},
				Status: schedulingapi.PodGroupStatus{
					Phase: schedulingapi.PodGroupInqueue,
				},
			},
			PodRetainPhase: state.PodRetainPhaseNone,
			UpdateStatus:   nil,
			JobInfo: &apis.JobInfo{
				Namespace: namespace,
				Name:      "jobinfo1",
				Pods: map[string]map[string]*v1.Pod{
					"task1": {
						"job1-task1-0": buildPod(namespace, "job1-task1-0", v1.PodRunning, nil),
						"job1-task1-1": buildPod(namespace, "job1-task1-1", v1.PodRunning, nil),
					},
				},
			},
			Pods: map[string]*v1.Pod{
				"job1-task1-0": buildPod(namespace, "job1-task1-0", v1.PodRunning, nil),
				"job1-task1-1": buildPod(namespace, "job1-task1-1", v1.PodRunning, nil),
			},
			TotalNumPods: 6,
			Plugins:      []string{"svc", "ssh", "env"},
			ExpectVal:    nil,
		},
		{
			Name: "SyncJob with dependsOn job can't find the dependent task",
			/*
				Work dependsOn Master task, preempt actions causes controller deadlock
				   controller                master,work             scheduler
				       |                           |  <---preempt-----  |
				       |                           |  <---kill work---  |
				       | ----watch work kill---->  |                    |
					   |                           |  <---kill master-- |
				       | ----create work pods--->  |                    |
				       | --wait master running-->  |                    |
				       |                           |                    |
					   | ---watch master kill--->  |                    |
				       | --push master to queue->  |                    |
				       | -wait process to create-> |                    |
			*/
			Job: &v1alpha1.Job{
				ObjectMeta: metav1.ObjectMeta{
					Name:            "job1",
					Namespace:       namespace,
					ResourceVersion: "100",
					UID:             "e7f18111-1cec-11ea-b688-fa163ec79500",
				},
				Spec: v1alpha1.JobSpec{
					Tasks: []v1alpha1.TaskSpec{
						{
							Name:     "master",
							Replicas: 1,
							Template: v1.PodTemplateSpec{
								ObjectMeta: metav1.ObjectMeta{
									Name:      "pods",
									Namespace: namespace,
								},
								Spec: v1.PodSpec{
									Containers: []v1.Container{
										{
											Name: "Containers",
										},
									},
								},
							},
						},
						{
							Name:     "work",
							Replicas: 3,
							Template: v1.PodTemplateSpec{
								ObjectMeta: metav1.ObjectMeta{
									Name:      "pods",
									Namespace: namespace,
								},
								Spec: v1.PodSpec{
									Containers: []v1.Container{
										{
											Name: "Containers",
										},
									},
								},
							},
							DependsOn: &v1alpha1.DependsOn{
								Name: []string{"master"},
							},
						},
					},
				},
				Status: v1alpha1.JobStatus{
					State: v1alpha1.JobState{
						Phase: v1alpha1.Pending,
					},
				},
			},
			PodGroup: &schedulingapi.PodGroup{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "job1-e7f18111-1cec-11ea-b688-fa163ec79500",
					Namespace: namespace,
				},
				Spec: schedulingapi.PodGroupSpec{
					MinResources:  &v1.ResourceList{},
					MinTaskMember: map[string]int32{},
				},
				Status: schedulingapi.PodGroupStatus{
					Phase: schedulingapi.PodGroupInqueue,
				},
			},
			PodRetainPhase: state.PodRetainPhaseNone,
			UpdateStatus:   nil,
			JobInfo: &apis.JobInfo{
				Namespace: namespace,
				Name:      "jobinfo1",
				Pods: map[string]map[string]*v1.Pod{
					"work": {
						"job1-work-0": buildPod(namespace, "job1-work-0", v1.PodRunning, nil),
						"job1-work-1": buildPod(namespace, "job1-work-1", v1.PodRunning, nil),
					},
				},
			},
			Pods: map[string]*v1.Pod{
				"job1-work-0": buildPod(namespace, "job1-work-0", v1.PodRunning, nil),
				"job1-work-1": buildPod(namespace, "job1-work-1", v1.PodRunning, nil),
			},
			TotalNumPods: 4,
			Plugins:      []string{"svc", "ssh", "env"},
			ExpectVal:    nil,
		},
	}
	for i, testcase := range testcases {

		t.Run(testcase.Name, func(t *testing.T) {
			fakeController := newFakeController()

			patches := gomonkey.ApplyMethod(reflect.TypeOf(fakeController), "GetQueueInfo", func(_ *jobcontroller, _ string) (*schedulingapi.Queue, error) {
				return &schedulingapi.Queue{}, nil
			})

			defer patches.Reset()

			jobPlugins := make(map[string][]string)

			for _, plugin := range testcase.Plugins {
				jobPlugins[plugin] = make([]string, 0)
			}
			testcase.JobInfo.Job = testcase.Job
			testcase.JobInfo.Job.Spec.Plugins = jobPlugins

			fakeController.pgInformer.Informer().GetIndexer().Add(testcase.PodGroup)
			fakeController.vcClient.SchedulingV1beta1().PodGroups(testcase.PodGroup.Namespace).Create(context.TODO(), testcase.PodGroup, metav1.CreateOptions{})

			for _, pod := range testcase.Pods {
				_, err := fakeController.kubeClient.CoreV1().Pods(namespace).Create(context.TODO(), pod, metav1.CreateOptions{})
				if err != nil {
					t.Error("Error While Creating pods")
				}
			}

			_, err := fakeController.vcClient.BatchV1alpha1().Jobs(namespace).Create(context.TODO(), testcase.Job, metav1.CreateOptions{})
			if err != nil {
				t.Errorf("Expected no Error while creating job, but got error: %s", err)
			}

			err = fakeController.cache.Add(testcase.Job)
			if err != nil {
				t.Error("Error While Adding Job in cache")
			}

			err = fakeController.syncJob(testcase.JobInfo, nil)
			if err != testcase.ExpectVal {
				t.Errorf("Expected no error while syncing job, but got error: %s", err)
			}

			podList, err := fakeController.kubeClient.CoreV1().Pods(namespace).List(context.TODO(), metav1.ListOptions{})
			if err != nil {
				t.Errorf("Expected no error while listing pods, but got error %s in case %d", err, i)
			}
			if testcase.TotalNumPods != len(podList.Items) {
				t.Errorf("Expected Total number of pods to be same as podlist count: Expected: %d, Got: %d in case: %d", testcase.TotalNumPods, len(podList.Items), i)
			}
		})
	}
}

func TestCreateJobIOIfNotExistFunc(t *testing.T) {
	namespace := "test"

	testcases := []struct {
		Name      string
		Job       *v1alpha1.Job
		ExpextVal error
	}{
		{
			Name: "Create Job IO case",
			Job: &v1alpha1.Job{
				ObjectMeta: metav1.ObjectMeta{
					Name:            "job1",
					Namespace:       namespace,
					ResourceVersion: "100",
				},
				Spec: v1alpha1.JobSpec{
					Volumes: []v1alpha1.VolumeSpec{
						{
							VolumeClaimName: "pvc1",
						},
					},
				},
			},
			ExpextVal: errors.New("pvc pvc1 is not found, the job will be in the Pending state until the PVC is created"),
		},
	}

	for i, testcase := range testcases {

		t.Run(testcase.Name, func(t *testing.T) {
			fakeController := newFakeController()

			job, err := fakeController.createJobIOIfNotExist(testcase.Job)
			if testcase.ExpextVal == nil {
				if err != nil {
					t.Errorf("Expected Return value to be : %v, but got: %v in testcase %d", testcase.ExpextVal, err, i)
				}
			} else {
				if err == nil || err.Error() != testcase.ExpextVal.Error() {
					t.Errorf("Expected Return value to be : %v, but got: %v in testcase %d", testcase.ExpextVal.Error(), err.Error(), i)
				}
			}

			if len(job.Spec.Volumes) == 0 {
				t.Errorf("Expected number of volumes to be greater than 0 but got: %d in case: %d", len(job.Spec.Volumes), i)
			}
		})
	}
}

func TestCreatePVCFunc(t *testing.T) {
	namespace := "test"

	testcases := []struct {
		Name        string
		Job         *v1alpha1.Job
		VolumeClaim *v1.PersistentVolumeClaimSpec
		ExpextVal   error
	}{
		{
			Name: "CreatePVC success Case",
			Job: &v1alpha1.Job{
				ObjectMeta: metav1.ObjectMeta{
					Name:            "job1",
					Namespace:       namespace,
					ResourceVersion: "100",
				},
			},
			VolumeClaim: &v1.PersistentVolumeClaimSpec{
				VolumeName: "vol1",
			},
			ExpextVal: nil,
		},
	}

	for _, testcase := range testcases {
		t.Run(testcase.Name, func(t *testing.T) {
			fakeController := newFakeController()

			err := fakeController.createPVC(testcase.Job, "pvc1", testcase.VolumeClaim)
			if err != testcase.ExpextVal {
				t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpextVal, err)
			}
			_, err = fakeController.kubeClient.CoreV1().PersistentVolumeClaims(namespace).Get(context.TODO(), "pvc1", metav1.GetOptions{})
			if err != nil {
				t.Error("Expected PVC to get created, but not created")
			}
		})
	}
}

func TestCreatePodGroupIfNotExistFunc(t *testing.T) {
	namespace := "test"

	testcases := []struct {
		Name      string
		Job       *v1alpha1.Job
		ExpextVal error
	}{
		{
			Name: "CreatePodGroup success Case",
			Job: &v1alpha1.Job{
				ObjectMeta: metav1.ObjectMeta{
					Namespace:       namespace,
					Name:            "job1",
					ResourceVersion: "100",
					UID:             "e7f18111-1cec-11ea-b688-fa163ec79500",
				},
			},
			ExpextVal: nil,
		},
	}

	for _, testcase := range testcases {
		t.Run(testcase.Name, func(t *testing.T) {
			fakeController := newFakeController()

			err := fakeController.createOrUpdatePodGroup(testcase.Job)
			if err != testcase.ExpextVal {
				t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpextVal, err)
			}

			pgName := testcase.Job.Name + "-" + string(testcase.Job.UID)
			_, err = fakeController.vcClient.SchedulingV1beta1().PodGroups(namespace).Get(context.TODO(), pgName, metav1.GetOptions{})
			if err != nil {
				t.Error("Expected PodGroup to get created, but not created")
			}
		})

	}
}

func TestUpdatePodGroupIfJobUpdateFunc(t *testing.T) {
	namespace := "test"

	testcases := []struct {
		Name      string
		PodGroup  *schedulingapi.PodGroup
		Job       *v1alpha1.Job
		ExpectVal error
	}{
		{
			Name: "UpdatePodGroup success Case",
			PodGroup: &schedulingapi.PodGroup{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: namespace,
					Name:      "job1-e7f18111-1cec-11ea-b688-fa163ec79500",
				},
				Spec: schedulingapi.PodGroupSpec{
					MinResources: &v1.ResourceList{},
				},
			},
			Job: &v1alpha1.Job{
				ObjectMeta: metav1.ObjectMeta{
					Namespace:       namespace,
					Name:            "job1",
					ResourceVersion: "100",
					UID:             "e7f18111-1cec-11ea-b688-fa163ec79500",
				},
				Spec: v1alpha1.JobSpec{
					PriorityClassName: "new",
				},
			},
			ExpectVal: nil,
		},
	}

	for _, testcase := range testcases {
		t.Run(testcase.Name, func(t *testing.T) {
			fakeController := newFakeController()
			fakeController.pgInformer.Informer().GetIndexer().Add(testcase.PodGroup)
			fakeController.vcClient.SchedulingV1beta1().PodGroups(testcase.PodGroup.Namespace).Create(context.TODO(), testcase.PodGroup, metav1.CreateOptions{})

			err := fakeController.createOrUpdatePodGroup(testcase.Job)
			if err != testcase.ExpectVal {
				t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpectVal, err)
			}

			pgName := testcase.Job.Name + "-" + string(testcase.Job.UID)
			pg, err := fakeController.vcClient.SchedulingV1beta1().PodGroups(namespace).Get(context.TODO(), pgName, metav1.GetOptions{})
			if err != nil {
				t.Error("Expected PodGroup to be created, but not created")
			}
			if pg.Spec.PriorityClassName != testcase.Job.Spec.PriorityClassName {
				t.Errorf("Expected PodGroup.Spec.PriorityClassName to be updated to: %s, but got: %s", testcase.Job.Spec.PriorityClassName, pg.Spec.PriorityClassName)
			}

		})

	}

}

func TestDeleteJobPod(t *testing.T) {
	namespace := "test"

	testcases := []struct {
		Name      string
		Job       *v1alpha1.Job
		Pods      map[string]*v1.Pod
		DeletePod *v1.Pod
		ExpextVal error
	}{
		{
			Name: "DeleteJobPod success case",
			Job: &v1alpha1.Job{
				ObjectMeta: metav1.ObjectMeta{
					Name:            "job1",
					Namespace:       namespace,
					ResourceVersion: "100",
				},
			},
			Pods: map[string]*v1.Pod{
				"job1-task1-0": buildPod(namespace, "job1-task1-0", v1.PodRunning, nil),
				"job1-task1-1": buildPod(namespace, "job1-task1-1", v1.PodRunning, nil),
			},
			DeletePod: buildPod(namespace, "job1-task1-0", v1.PodRunning, nil),
			ExpextVal: nil,
		},
	}

	for _, testcase := range testcases {
		t.Run(testcase.Name, func(t *testing.T) {
			fakeController := newFakeController()

			for _, pod := range testcase.Pods {
				_, err := fakeController.kubeClient.CoreV1().Pods(namespace).Create(context.TODO(), pod, metav1.CreateOptions{})
				if err != nil {
					t.Error("Expected error not to occur")
				}
			}

			err := fakeController.deleteJobPod(testcase.Job.Name, testcase.DeletePod)
			if err != testcase.ExpextVal {
				t.Errorf("Expected return value to be equal to expected: %s, but got: %s", testcase.ExpextVal, err)
			}

			_, err = fakeController.kubeClient.CoreV1().Pods(namespace).Get(context.TODO(), "job1-task1-0", metav1.GetOptions{})
			if err == nil {
				t.Error("Expected Pod to be deleted but not deleted")
			}
		})
	}
}

repository: volcano-sh/volcano

repo_name: volcano-sh/volcano


text:
/*
 * Copyright 2021 InfAI (CC SES)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package tests

import (
	"context"
	"errors"
	"github.com/SENERGY-Platform/notifier/pkg/mqtt"
	"github.com/ory/dockertest/v3"
	"github.com/ory/dockertest/v3/docker"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.mongodb.org/mongo-driver/mongo/readpref"
	"log"
	"net"
	"os"
	"sync"
	"time"
)

func MongoContainer(ctx context.Context, wg *sync.WaitGroup) (hostPort string, ipAddress string, err error) {
	pool, err := dockertest.NewPool("")
	container, err := pool.RunWithOptions(&dockertest.RunOptions{
		Repository: "mongo",
		Tag:        "4.1.11",
	}, func(config *docker.HostConfig) {
		config.Tmpfs = map[string]string{"/data/db": "rw"}
	})
	if err != nil {
		return "", "", err
	}
	wg.Add(1)
	go func() {
		<-ctx.Done()
		log.Println("DEBUG: remove container " + container.Container.Name)
		container.Close()
		wg.Done()
	}()
	hostPort = container.GetPort("27017/tcp")
	err = pool.Retry(func() error {
		log.Println("try mongodb connection...")
		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
		client, err := mongo.Connect(ctx, options.Client().ApplyURI("mongodb://localhost:"+hostPort))
		err = client.Ping(ctx, readpref.Primary())
		return err
	})
	return hostPort, container.Container.NetworkSettings.IPAddress, err
}

func MqttContainer(ctx context.Context, wg *sync.WaitGroup) (brokerAddress string, err error) {
	pool, err := dockertest.NewPool("")
	container, err := pool.Run("erlio/docker-vernemq", "latest", []string{
		"DOCKER_VERNEMQ_ACCEPT_EULA=yes",
		"DOCKER_VERNEMQ_ALLOW_ANONYMOUS=on",
		"DOCKER_VERNEMQ_LOG__CONSOLE__LEVEL=error",
		//"DOCKER_VERNEMQ_SHARED_SUBSCRIPTION_POLICY=random",
		//"DOCKER_VERNEMQ_PLUGINS__VMQ_PASSWD=off",
		//"DOCKER_VERNEMQ_PLUGINS__VMQ_ACL=off",
		//"DOCKER_VERNEMQ_PLUGINS__VMQ_WEBHOOKS=on",
	})
	wg.Add(1)
	go func() {
		<-ctx.Done()
		log.Println("DEBUG: remove container " + container.Container.Name)
		container.Close()
		wg.Done()
	}()
	go Dockerlog(pool, ctx, container, "VERNEMQ")
	brokerAddress = "localhost:" + container.GetPort("1883/tcp")
	err = pool.Retry(func() error {
		log.Println("try mqtt connection...")
		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
		defer cancel()
		pub, err := mqtt.NewPublisher(ctx, brokerAddress, "", "", "connection-check", 0, true)
		if err != nil {
			return err
		}
		if !pub.GetClient().IsConnected() {
			return errors.New("not connected")
		}
		return nil
	})
	return brokerAddress, err
}

func getFreePort() (int, error) {
	addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
	if err != nil {
		return 0, err
	}

	listener, err := net.ListenTCP("tcp", addr)
	if err != nil {
		return 0, err
	}
	defer listener.Close()
	return listener.Addr().(*net.TCPAddr).Port, nil
}

func Dockerlog(pool *dockertest.Pool, ctx context.Context, repo *dockertest.Resource, name string) {
	out := &LogWriter{logger: log.New(os.Stdout, "["+name+"]", 0)}
	err := pool.Client.Logs(docker.LogsOptions{
		Stdout:       true,
		Stderr:       true,
		Context:      ctx,
		Container:    repo.Container.ID,
		Follow:       true,
		OutputStream: out,
		ErrorStream:  out,
	})
	if err != nil && err != context.Canceled {
		log.Println("DEBUG-ERROR: unable to start docker log", name, err)
	}
}

type LogWriter struct {
	logger *log.Logger
}

func (this *LogWriter) Write(p []byte) (n int, err error) {
	this.logger.Print(string(p))
	return len(p), nil
}

repository: SENERGY-Platform/notifier

repo_name: SENERGY-Platform/notifier


text:
package config

import "time"

type pubSubDriver string

const (
	PubSubDriverMemory pubSubDriver = "memory"
	PubSubDriverRedis  pubSubDriver = "redis"
)

func (d pubSubDriver) String() string { return string(d) }

type storageDriver string

const (
	StorageDriverMemory storageDriver = "memory"
	StorageDriverRedis  storageDriver = "redis"
)

func (d storageDriver) String() string { return string(d) }

type Config struct {
	MaxRequests          uint16
	SessionTTL           time.Duration
	IgnoreHeaderPrefixes []string
	MaxRequestBodySize   uint32 // maximal webhook request body size (in bytes), zero means unlimited

	StorageDriver storageDriver
	PubSubDriver  pubSubDriver

	WebSockets struct {
		MaxClients  uint32        // zero means unlimited
		MaxLifetime time.Duration // zero means unlimited
	}
}

repository: boberko/webhook-tester

repo_name: boberko/webhook-tester


text:
package ackhandler

import (
	"github.com/lucas-clemente/quic-go/internal/protocol"
	"github.com/lucas-clemente/quic-go/internal/utils"
	"github.com/lucas-clemente/quic-go/internal/wire"
	"github.com/lucas-clemente/quic-go/qerr"
)

type receivedSymbolHistory struct {
	// ranges是个list，里面的元素是根节点本体和list长度，节点有prev和next方法，并存有所属的list。节点的value是range，包括start和end
	ranges                        *utils.SymbolIntervalList
	lowestInReceivedSymbolNumbers protocol.SymbolNumber
}

var errTooManyOutstandingReceivedSymbolRanges = qerr.Error(qerr.TooManyOutstandingReceivedSymbols, "Too many outstanding received Symbol ACK ranges")

func newreceivedSymbolHistory() *receivedSymbolHistory {
	return &receivedSymbolHistory{
		ranges: utils.NewSymbolIntervalList(),
	}
}

func (h *receivedSymbolHistory) ReceiveSymbol(p protocol.SymbolNumber) error {
	// 处理超出长度错误，history追踪了len个range
	if h.ranges.Len() >= protocol.MaxTrackedReceivedSymbolAckRanges {
		return errTooManyOutstandingReceivedSymbolRanges
	}

	if h.ranges.Len() == 0 {
		h.ranges.PushBack(utils.SymbolTnterval{Start: p, End: p})
		return nil
	}

	for el := h.ranges.Back(); el != nil; el = el.Prev() {
		if p >= el.Value.Start && p <= el.Value.End {
			return nil
		}

		// 说明没在当前的range中找到

		var rangeExtended bool
		if el.Value.End+1 == p {
			rangeExtended = true
			el.Value.End = p
		} else if el.Value.Start-1 == p {
			rangeExtended = true
			el.Value.Start = p
		}

		if rangeExtended {
			prev := el.Prev()
			if prev != nil && prev.Value.End+1 == el.Value.Start {
				prev.Value.End = el.Value.End
				h.ranges.Remove(el)
				return nil
			}
			return nil
		}

		if p > el.Value.End {
			h.ranges.InsertAfter(utils.SymbolTnterval{Start: p, End: p}, el)
			return nil
		}
	}

	h.ranges.InsertBefore(utils.SymbolTnterval{Start: p, End: p}, h.ranges.Front())
	return nil
}

// 删除history的el, 直到el的范围包含了p
func (h *receivedSymbolHistory) DeleteUpTo(p protocol.SymbolNumber) {
	h.lowestInReceivedSymbolNumbers = utils.MaxSymbolNumber(h.lowestInReceivedSymbolNumbers, p+1)

	nextEl := h.ranges.Front()
	for el := h.ranges.Front(); nextEl != nil; el = nextEl {
		nextEl = el.Next()

		if p >= el.Value.Start && p < el.Value.End {
			el.Value.Start = p + 1
		} else if el.Value.End <= p {
			h.ranges.Remove(el)
		} else {
			return
		}
	}
}

// 遍历所有symbol，将symbol的range返回
func (h *receivedSymbolHistory) GetSymbolRanges() []wire.SymbolRange {
	if h.ranges.Len() == 0 {
		return nil
	}

	symbolRanges := make([]wire.SymbolRange, h.ranges.Len())
	i := 0
	for el := h.ranges.Back(); el != nil; el = el.Prev() {
		symbolRanges[i] = wire.SymbolRange{First: protocol.PacketNumber(el.Value.Start), Last: protocol.PacketNumber(el.Value.End)}
		i++
	}
	return symbolRanges
}

// r := h.ranges.Back().Value，返回r的first和last组成的range
func (h *receivedPacketHistory) GetHighestSymbolRange() wire.SymbolRange {
	symbolRange := wire.SymbolRange{}

	if h.ranges.Len() > 0 {
		r := h.ranges.Back().Value
		symbolRange.First = r.Start
		symbolRange.Last = r.End
	}
	return symbolRange
}

repository: ZhaoLee-hust/quic-go

repo_name: ZhaoLee-hust/quic-go


text:
include(vcpkg_common_functions)

set(benchmarktools_VERSION 1.1.0)

vcpkg_download_distfile(
    OUT_DISTFILE_PATH
    URLS "https://mp-force.ziti.uni-heidelberg.de/kmbeutel/benchmarktools/-/archive/${benchmarktools_VERSION}/benchmarktools-${benchmarktools_VERSION}.tar.gz"
    FILENAME "benchmarktools-${benchmarktools_VERSION}.tar.gz"
    SHA512 92b0c9cbdf5e1f5db06f68d5bba16bd96c1897d15fa0b9c33a74af97e06256a4eabb42c61126b6461ab3a62cd90d58f06d4279495435e550c5528c543e96beef
)

set(SOURCE_PATH "${CURRENT_BUILDTREES_DIR}/src/")
vcpkg_extract_source_archive(${OUT_DISTFILE_PATH} "${SOURCE_PATH}")
vcpkg_configure_cmake(
    SOURCE_PATH "${SOURCE_PATH}/benchmarktools-${benchmarktools_VERSION}"
    PREFER_NINJA
    OPTIONS
        -DEXPORT_BUILD_DIR=OFF
        -DBUILD_TESTS=OFF
)

vcpkg_install_cmake()

vcpkg_fixup_cmake_targets(CONFIG_PATH "share/cmake/benchmarktools-${benchmarktools_VERSION}" TARGET_PATH "share/benchmarktools")

file(REMOVE_RECURSE
    "${CURRENT_PACKAGES_DIR}/benchmarktools-${benchmarktools_VERSION}"
    "${CURRENT_PACKAGES_DIR}/debug"
)

file(
    INSTALL "${SOURCE_PATH}/benchmarktools-${benchmarktools_VERSION}/LICENSE.txt"
    DESTINATION "${CURRENT_PACKAGES_DIR}/share/benchmarktools"
    RENAME copyright)

repository: MVoz/vcpkg-old

repo_name: MVoz/vcpkg-old

extension: cmake


text:
SUMMARY = "HTTP library with thread-safe connection pooling for Python"

PR = "${INC_PR}.0"

require python-urllib3.inc

inherit setuptools

DEPENDS += "six-native"

# Change install directory from "site-packages" to "dist-packages"
PYTHON_SITEPACKAGES_DIR = "${libdir}/${PYTHON_DIR}/dist-packages"

do_install_append() {
	# Remove unwanted files
	find ${D}${libdir} -type f -name "*.pyc" -exec rm -f {} \;
	rm -rf ${D}${libdir}/${PYTHON_DIR}/dist-packages/urllib3-1.9.1-py2.7.egg-info/SOURCES.txt
}

BBCLASSEXTEND = "native"

repository: manut/meta-combo

repo_name: manut/meta-combo

branch_name: refs/heads/morty


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

/*
Package protonum is a generated protocol buffer package.

It is generated from these files:
	protonum.proto

It has these top-level messages:
	ProtoNum
	KeyValue
	TopsyTurvy
	Topsy
	Turvy
	Knot
	BightKnot
*/
package protonum

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
import gzip "compress/gzip"
import bytes "bytes"
import ioutil "io/ioutil"

import strings "strings"
import reflect "reflect"

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

// ProtoNum is used for testing of the protonum package.
type ProtoNum struct {
	KeyValue         []*KeyValue `protobuf:"bytes,2,rep,name=KeyValue" json:"KeyValue,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

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

func (m *ProtoNum) GetKeyValue() []*KeyValue {
	if m != nil {
		return m.KeyValue
	}
	return nil
}

// KeyValue is used for testing of the protonum package.
type KeyValue struct {
	Key              *string `protobuf:"bytes,1,opt,name=Key" json:"Key,omitempty"`
	Value            *string `protobuf:"bytes,2,opt,name=Value" json:"Value,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *KeyValue) GetKey() string {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return ""
}

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

// TopsyTurvy is used for testing of the protonum package.
type TopsyTurvy struct {
	Topsy            *Topsy `protobuf:"bytes,1,opt,name=Topsy" json:"Topsy,omitempty"`
	Turvy            *Turvy `protobuf:"bytes,2,opt,name=Turvy" json:"Turvy,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TopsyTurvy) GetTopsy() *Topsy {
	if m != nil {
		return m.Topsy
	}
	return nil
}

func (m *TopsyTurvy) GetTurvy() *Turvy {
	if m != nil {
		return m.Turvy
	}
	return nil
}

// Topsy is used for testing of the protonum package.
type Topsy struct {
	A                *int64 `protobuf:"varint,1,opt,name=A" json:"A,omitempty"`
	B                *int64 `protobuf:"varint,2,opt,name=B" json:"B,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *Topsy) GetA() int64 {
	if m != nil && m.A != nil {
		return *m.A
	}
	return 0
}

func (m *Topsy) GetB() int64 {
	if m != nil && m.B != nil {
		return *m.B
	}
	return 0
}

// Turvy is used for testing of the protonum package.
type Turvy struct {
	B                *int64 `protobuf:"varint,1,opt,name=B" json:"B,omitempty"`
	A                *int64 `protobuf:"varint,2,opt,name=A" json:"A,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *Turvy) GetB() int64 {
	if m != nil && m.B != nil {
		return *m.B
	}
	return 0
}

func (m *Turvy) GetA() int64 {
	if m != nil && m.A != nil {
		return *m.A
	}
	return 0
}

// Knot is used for testing of the protonum package.
type Knot struct {
	Bight            []*BightKnot `protobuf:"bytes,1,rep,name=Bight" json:"Bight,omitempty"`
	Elbow            *bool        `protobuf:"varint,2,opt,name=Elbow" json:"Elbow,omitempty"`
	BitterEnd        *Knot        `protobuf:"bytes,3,opt,name=BitterEnd" json:"BitterEnd,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

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

func (m *Knot) GetBight() []*BightKnot {
	if m != nil {
		return m.Bight
	}
	return nil
}

func (m *Knot) GetElbow() bool {
	if m != nil && m.Elbow != nil {
		return *m.Elbow
	}
	return false
}

func (m *Knot) GetBitterEnd() *Knot {
	if m != nil {
		return m.BitterEnd
	}
	return nil
}

// BightKnot is used for testing of the protonum package.
type BightKnot struct {
	Loop             *Knot  `protobuf:"bytes,1,opt,name=Loop" json:"Loop,omitempty"`
	Turn             *bool  `protobuf:"varint,2,opt,name=Turn" json:"Turn,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *BightKnot) GetLoop() *Knot {
	if m != nil {
		return m.Loop
	}
	return nil
}

func (m *BightKnot) GetTurn() bool {
	if m != nil && m.Turn != nil {
		return *m.Turn
	}
	return false
}

func init() {
	proto.RegisterType((*ProtoNum)(nil), "protonum.ProtoNum")
	proto.RegisterType((*KeyValue)(nil), "protonum.KeyValue")
	proto.RegisterType((*TopsyTurvy)(nil), "protonum.TopsyTurvy")
	proto.RegisterType((*Topsy)(nil), "protonum.Topsy")
	proto.RegisterType((*Turvy)(nil), "protonum.Turvy")
	proto.RegisterType((*Knot)(nil), "protonum.Knot")
	proto.RegisterType((*BightKnot)(nil), "protonum.BightKnot")
}
func (this *ProtoNum) Description() (desc *descriptor.FileDescriptorSet) {
	return ProtonumDescription()
}
func (this *KeyValue) Description() (desc *descriptor.FileDescriptorSet) {
	return ProtonumDescription()
}
func (this *TopsyTurvy) Description() (desc *descriptor.FileDescriptorSet) {
	return ProtonumDescription()
}
func (this *Topsy) Description() (desc *descriptor.FileDescriptorSet) {
	return ProtonumDescription()
}
func (this *Turvy) Description() (desc *descriptor.FileDescriptorSet) {
	return ProtonumDescription()
}
func (this *Knot) Description() (desc *descriptor.FileDescriptorSet) {
	return ProtonumDescription()
}
func (this *BightKnot) Description() (desc *descriptor.FileDescriptorSet) {
	return ProtonumDescription()
}
func ProtonumDescription() (desc *descriptor.FileDescriptorSet) {
	d := &descriptor.FileDescriptorSet{}
	var gzipped = []byte{
		// 3869 bytes of a gzipped FileDescriptorSet
		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x5b, 0x70, 0x1b, 0xd7,
		0x79, 0x36, 0x6e, 0x24, 0xf0, 0x03, 0x04, 0x97, 0x87, 0xb4, 0x04, 0xd1, 0xb1, 0x25, 0xc1, 0x76,
		0x44, 0xd9, 0x09, 0x95, 0x91, 0x2d, 0xd9, 0x5a, 0x35, 0x71, 0x01, 0x70, 0xc5, 0x40, 0x26, 0x09,
		0x64, 0x01, 0xfa, 0x96, 0xe9, 0xec, 0x2c, 0x17, 0x07, 0xe0, 0x4a, 0x8b, 0xdd, 0xcd, 0xee, 0x42,
		0x32, 0x35, 0x7d, 0x70, 0xc7, 0xbd, 0x4c, 0xa6, 0xd3, 0x7b, 0x67, 0x92, 0xb8, 0x8e, 0x7b, 0x99,
		0x49, 0xdd, 0xa6, 0xb7, 0xa4, 0x69, 0xd3, 0xcb, 0x53, 0x5f, 0xd2, 0xf6, 0xa9, 0x33, 0x79, 0xef,
		0x43, 0x2f, 0x9e, 0xe9, 0xcd, 0x6d, 0xd2, 0xd6, 0x0f, 0x9d, 0xd1, 0x4b, 0xe7, 0xdc, 0x16, 0xbb,
		0x00, 0xa8, 0x05, 0x33, 0x63, 0xe7, 0x89, 0x3c, 0xff, 0xf9, 0xbf, 0xef, 0x9c, 0xf3, 0x9f, 0xff,
		0xfc, 0xff, 0x7f, 0xce, 0x02, 0xbe, 0x77, 0x0d, 0xce, 0x0d, 0x1c, 0x67, 0x60, 0xe1, 0x4b, 0xae,
		0xe7, 0x04, 0xce, 0xc1, 0xa8, 0x7f, 0xa9, 0x87, 0x7d, 0xc3, 0x33, 0xdd, 0xc0, 0xf1, 0x36, 0xa9,
		0x0c, 0x2d, 0x33, 0x8d, 0x4d, 0xa1, 0x51, 0xdd, 0x85, 0x95, 0x1b, 0xa6, 0x85, 0xb7, 0x42, 0xc5,
		0x0e, 0x0e, 0xd0, 0xf3, 0x90, 0xed, 0x9b, 0x16, 0xae, 0xa4, 0xce, 0x65, 0x36, 0x8a, 0x97, 0x9f,
		0xd8, 0x9c, 0x00, 0x6d, 0xc6, 0x11, 0x6d, 0x22, 0x56, 0x29, 0xa2, 0xfa, 0x5e, 0x16, 0x56, 0x67,
		0xf4, 0x22, 0x04, 0x59, 0x5b, 0x1f, 0x12, 0xc6, 0xd4, 0x46, 0x41, 0xa5, 0xff, 0xa3, 0x0a, 0x2c,
		0xba, 0xba, 0x71, 0x5b, 0x1f, 0xe0, 0x4a, 0x9a, 0x8a, 0x45, 0x13, 0x3d, 0x06, 0xd0, 0xc3, 0x2e,
		0xb6, 0x7b, 0xd8, 0x36, 0x8e, 0x2a, 0x99, 0x73, 0x99, 0x8d, 0x82, 0x1a, 0x91, 0xa0, 0xa7, 0x61,
		0xc5, 0x1d, 0x1d, 0x58, 0xa6, 0xa1, 0x45, 0xd4, 0xe0, 0x5c, 0x66, 0x23, 0xa7, 0x4a, 0xac, 0x63,
		0x6b, 0xac, 0x7c, 0x01, 0x96, 0xef, 0x62, 0xfd, 0x76, 0x54, 0xb5, 0x48, 0x55, 0xcb, 0x44, 0x1c,
		0x51, 0x6c, 0x40, 0x69, 0x88, 0x7d, 0x5f, 0x1f, 0x60, 0x2d, 0x38, 0x72, 0x71, 0x25, 0x4b, 0x57,
		0x7f, 0x6e, 0x6a, 0xf5, 0x93, 0x2b, 0x2f, 0x72, 0x54, 0xf7, 0xc8, 0xc5, 0xa8, 0x06, 0x05, 0x6c,
		0x8f, 0x86, 0x8c, 0x21, 0x77, 0x8c, 0xfd, 0x14, 0x7b, 0x34, 0x9c, 0x64, 0xc9, 0x13, 0x18, 0xa7,
		0x58, 0xf4, 0xb1, 0x77, 0xc7, 0x34, 0x70, 0x65, 0x81, 0x12, 0x5c, 0x98, 0x22, 0xe8, 0xb0, 0xfe,
		0x49, 0x0e, 0x81, 0x43, 0x0d, 0x28, 0xe0, 0xd7, 0x03, 0x6c, 0xfb, 0xa6, 0x63, 0x57, 0x16, 0x29,
		0xc9, 0x93, 0x33, 0x76, 0x11, 0x5b, 0xbd, 0x49, 0x8a, 0x31, 0x0e, 0x5d, 0x85, 0x45, 0xc7, 0x0d,
		0x4c, 0xc7, 0xf6, 0x2b, 0xf9, 0x73, 0xa9, 0x8d, 0xe2, 0xe5, 0x8f, 0xcd, 0x74, 0x84, 0x16, 0xd3,
		0x51, 0x85, 0x32, 0x6a, 0x82, 0xe4, 0x3b, 0x23, 0xcf, 0xc0, 0x9a, 0xe1, 0xf4, 0xb0, 0x66, 0xda,
		0x7d, 0xa7, 0x52, 0xa0, 0x04, 0x67, 0xa7, 0x17, 0x42, 0x15, 0x1b, 0x4e, 0x0f, 0x37, 0xed, 0xbe,
		0xa3, 0x96, 0xfd, 0x58, 0x1b, 0x9d, 0x82, 0x05, 0xff, 0xc8, 0x0e, 0xf4, 0xd7, 0x2b, 0x25, 0xea,
		0x21, 0xbc, 0x55, 0xfd, 0x8b, 0x05, 0x58, 0x9e, 0xc7, 0xc5, 0xae, 0x43, 0xae, 0x4f, 0x56, 0x59,
		0x49, 0x9f, 0xc4, 0x06, 0x0c, 0x13, 0x37, 0xe2, 0xc2, 0x0f, 0x68, 0xc4, 0x1a, 0x14, 0x6d, 0xec,
		0x07, 0xb8, 0xc7, 0x3c, 0x22, 0x33, 0xa7, 0x4f, 0x01, 0x03, 0x4d, 0xbb, 0x54, 0xf6, 0x07, 0x72,
		0xa9, 0x57, 0x60, 0x39, 0x9c, 0x92, 0xe6, 0xe9, 0xf6, 0x40, 0xf8, 0xe6, 0xa5, 0xa4, 0x99, 0x6c,
		0x2a, 0x02, 0xa7, 0x12, 0x98, 0x5a, 0xc6, 0xb1, 0x36, 0xda, 0x02, 0x70, 0x6c, 0xec, 0xf4, 0xb5,
		0x1e, 0x36, 0xac, 0x4a, 0xfe, 0x18, 0x2b, 0xb5, 0x88, 0xca, 0x94, 0x95, 0x1c, 0x26, 0x35, 0x2c,
		0x74, 0x6d, 0xec, 0x6a, 0x8b, 0xc7, 0x78, 0xca, 0x2e, 0x3b, 0x64, 0x53, 0xde, 0xb6, 0x0f, 0x65,
		0x0f, 0x13, 0xbf, 0xc7, 0x3d, 0xbe, 0xb2, 0x02, 0x9d, 0xc4, 0x66, 0xe2, 0xca, 0x54, 0x0e, 0x63,
		0x0b, 0x5b, 0xf2, 0xa2, 0x4d, 0xf4, 0x38, 0x84, 0x02, 0x8d, 0xba, 0x15, 0xd0, 0x28, 0x54, 0x12,
		0xc2, 0x3d, 0x7d, 0x88, 0xd7, 0xef, 0x41, 0x39, 0x6e, 0x1e, 0xb4, 0x06, 0x39, 0x3f, 0xd0, 0xbd,
		0x80, 0x7a, 0x61, 0x4e, 0x65, 0x0d, 0x24, 0x41, 0x06, 0xdb, 0x3d, 0x1a, 0xe5, 0x72, 0x2a, 0xf9,
		0x17, 0xfd, 0xe8, 0x78, 0xc1, 0x19, 0xba, 0xe0, 0x8f, 0x4f, 0xef, 0x68, 0x8c, 0x79, 0x72, 0xdd,
		0xeb, 0xcf, 0xc1, 0x52, 0x6c, 0x01, 0xf3, 0x0e, 0x5d, 0xfd, 0x71, 0x78, 0x78, 0x26, 0x35, 0x7a,
		0x05, 0xd6, 0x46, 0xb6, 0x69, 0x07, 0xd8, 0x73, 0x3d, 0x4c, 0x3c, 0x96, 0x0d, 0x55, 0xf9, 0x97,
		0xc5, 0x63, 0x7c, 0x6e, 0x3f, 0xaa, 0xcd, 0x58, 0xd4, 0xd5, 0xd1, 0xb4, 0xf0, 0xa9, 0x42, 0xfe,
		0x5f, 0x17, 0xa5, 0x37, 0xde, 0x78, 0xe3, 0x8d, 0x74, 0xf5, 0xcb, 0x0b, 0xb0, 0x36, 0xeb, 0xcc,
		0xcc, 0x3c, 0xbe, 0xa7, 0x60, 0xc1, 0x1e, 0x0d, 0x0f, 0xb0, 0x47, 0x8d, 0x94, 0x53, 0x79, 0x0b,
		0xd5, 0x20, 0x67, 0xe9, 0x07, 0xd8, 0xaa, 0x64, 0xcf, 0xa5, 0x36, 0xca, 0x97, 0x9f, 0x9e, 0xeb,
		0x54, 0x6e, 0xee, 0x10, 0x88, 0xca, 0x90, 0xe8, 0x33, 0x90, 0xe5, 0x21, 0x9a, 0x30, 0x3c, 0x35,
		0x1f, 0x03, 0x39, 0x4b, 0x2a, 0xc5, 0xa1, 0x47, 0xa0, 0x40, 0xfe, 0x32, 0xdf, 0x58, 0xa0, 0x73,
		0xce, 0x13, 0x01, 0xf1, 0x0b, 0xb4, 0x0e, 0x79, 0x7a, 0x4c, 0x7a, 0x58, 0xa4, 0xb6, 0xb0, 0x4d,
		0x1c, 0xab, 0x87, 0xfb, 0xfa, 0xc8, 0x0a, 0xb4, 0x3b, 0xba, 0x35, 0xc2, 0xd4, 0xe1, 0x0b, 0x6a,
		0x89, 0x0b, 0x5f, 0x22, 0x32, 0x74, 0x16, 0x8a, 0xec, 0x54, 0x99, 0x76, 0x0f, 0xbf, 0x4e, 0xa3,
		0x67, 0x4e, 0x65, 0x07, 0xad, 0x49, 0x24, 0x64, 0xf8, 0x5b, 0xbe, 0x63, 0x0b, 0xd7, 0xa4, 0x43,
		0x10, 0x01, 0x1d, 0xfe, 0xb9, 0xc9, 0xc0, 0xfd, 0xe8, 0xec, 0xe5, 0x4d, 0xfa, 0x54, 0xf5, 0xdb,
		0x69, 0xc8, 0xd2, 0x78, 0xb1, 0x0c, 0xc5, 0xee, 0xab, 0x6d, 0x45, 0xdb, 0x6a, 0xed, 0xd7, 0x77,
		0x14, 0x29, 0x85, 0xca, 0x00, 0x54, 0x70, 0x63, 0xa7, 0x55, 0xeb, 0x4a, 0xe9, 0xb0, 0xdd, 0xdc,
		0xeb, 0x5e, 0x7d, 0x56, 0xca, 0x84, 0x80, 0x7d, 0x26, 0xc8, 0x46, 0x15, 0x9e, 0xb9, 0x2c, 0xe5,
		0x90, 0x04, 0x25, 0x46, 0xd0, 0x7c, 0x45, 0xd9, 0xba, 0xfa, 0xac, 0xb4, 0x10, 0x97, 0x3c, 0x73,
		0x59, 0x5a, 0x44, 0x4b, 0x50, 0xa0, 0x92, 0x7a, 0xab, 0xb5, 0x23, 0xe5, 0x43, 0xce, 0x4e, 0x57,
		0x6d, 0xee, 0x6d, 0x4b, 0x85, 0x90, 0x73, 0x5b, 0x6d, 0xed, 0xb7, 0x25, 0x08, 0x19, 0x76, 0x95,
		0x4e, 0xa7, 0xb6, 0xad, 0x48, 0xc5, 0x50, 0xa3, 0xfe, 0x6a, 0x57, 0xe9, 0x48, 0xa5, 0xd8, 0xb4,
		0x9e, 0xb9, 0x2c, 0x2d, 0x85, 0x43, 0x28, 0x7b, 0xfb, 0xbb, 0x52, 0x19, 0xad, 0xc0, 0x12, 0x1b,
		0x42, 0x4c, 0x62, 0x79, 0x42, 0x74, 0xf5, 0x59, 0x49, 0x1a, 0x4f, 0x84, 0xb1, 0xac, 0xc4, 0x04,
		0x57, 0x9f, 0x95, 0x50, 0xb5, 0x01, 0x39, 0xea, 0x5d, 0x08, 0x41, 0x79, 0xa7, 0x56, 0x57, 0x76,
		0xb4, 0x56, 0xbb, 0xdb, 0x6c, 0xed, 0xd5, 0x76, 0xa4, 0xd4, 0x58, 0xa6, 0x2a, 0x9f, 0xdb, 0x6f,
		0xaa, 0xca, 0x96, 0x94, 0x8e, 0xca, 0xda, 0x4a, 0xad, 0xab, 0x6c, 0x49, 0x99, 0xaa, 0x01, 0x6b,
		0xb3, 0xe2, 0xe4, 0xcc, 0x93, 0x11, 0xd9, 0xe2, 0xf4, 0x31, 0x5b, 0x4c, 0xb9, 0xa6, 0xb6, 0xf8,
		0x9f, 0xd3, 0xb0, 0x3a, 0x23, 0x57, 0xcc, 0x1c, 0xe4, 0x05, 0xc8, 0x31, 0x17, 0x65, 0xd9, 0xf3,
		0xe2, 0xcc, 0xa4, 0x43, 0x1d, 0x76, 0x2a, 0x83, 0x52, 0x5c, 0xb4, 0x82, 0xc8, 0x1c, 0x53, 0x41,
		0x10, 0x8a, 0xa9, 0x98, 0xfe, 0x63, 0x53, 0x31, 0x9d, 0xa5, 0xbd, 0xab, 0xf3, 0xa4, 0x3d, 0x2a,
		0x3b, 0x59, 0x6c, 0xcf, 0xcd, 0x88, 0xed, 0xd7, 0x61, 0x65, 0x8a, 0x68, 0xee, 0x18, 0xfb, 0x66,
		0x0a, 0x2a, 0xc7, 0x19, 0x27, 0x21, 0xd2, 0xa5, 0x63, 0x91, 0xee, 0xfa, 0xa4, 0x05, 0xcf, 0x1f,
		0xbf, 0x09, 0x53, 0x7b, 0xfd, 0x6e, 0x0a, 0x4e, 0xcd, 0xae, 0x14, 0x67, 0xce, 0xe1, 0x33, 0xb0,
		0x30, 0xc4, 0xc1, 0xa1, 0x23, 0xaa, 0xa5, 0x8f, 0xcf, 0xc8, 0xc1, 0xa4, 0x7b, 0x72, 0xb3, 0x39,
		0x2a, 0x9a, 0xc4, 0x33, 0xc7, 0x95, 0x7b, 0x6c, 0x36, 0x53, 0x33, 0xfd, 0x62, 0x1a, 0x1e, 0x9e,
		0x49, 0x3e, 0x73, 0xa2, 0x8f, 0x02, 0x98, 0xb6, 0x3b, 0x0a, 0x58, 0x45, 0xc4, 0x02, 0x6c, 0x81,
		0x4a, 0x68, 0xf0, 0x22, 0xc1, 0x73, 0x14, 0x84, 0xfd, 0x19, 0xda, 0x0f, 0x4c, 0x44, 0x15, 0x9e,
		0x1f, 0x4f, 0x34, 0x4b, 0x27, 0xfa, 0xd8, 0x31, 0x2b, 0x9d, 0x72, 0xcc, 0x4f, 0x81, 0x64, 0x58,
		0x26, 0xb6, 0x03, 0xcd, 0x0f, 0x3c, 0xac, 0x0f, 0x4d, 0x7b, 0x40, 0x33, 0x48, 0x5e, 0xce, 0xf5,
		0x75, 0xcb, 0xc7, 0xea, 0x32, 0xeb, 0xee, 0x88, 0x5e, 0x82, 0xa0, 0x0e, 0xe4, 0x45, 0x10, 0x0b,
		0x31, 0x04, 0xeb, 0x0e, 0x11, 0xd5, 0x6f, 0xe5, 0xa1, 0x18, 0xa9, 0xab, 0xd1, 0x79, 0x28, 0xdd,
		0xd2, 0xef, 0xe8, 0x9a, 0xb8, 0x2b, 0x31, 0x4b, 0x14, 0x89, 0xac, 0xcd, 0xef, 0x4b, 0x9f, 0x82,
		0x35, 0xaa, 0xe2, 0x8c, 0x02, 0xec, 0x69, 0x86, 0xa5, 0xfb, 0x3e, 0x35, 0x5a, 0x9e, 0xaa, 0x22,
		0xd2, 0xd7, 0x22, 0x5d, 0x0d, 0xd1, 0x83, 0xae, 0xc0, 0x2a, 0x45, 0x0c, 0x47, 0x56, 0x60, 0xba,
		0x16, 0xd6, 0xc8, 0xed, 0xcd, 0xa7, 0x99, 0x24, 0x9c, 0xd9, 0x0a, 0xd1, 0xd8, 0xe5, 0x0a, 0x64,
		0x46, 0x3e, 0xda, 0x82, 0x47, 0x29, 0x6c, 0x80, 0x6d, 0xec, 0xe9, 0x01, 0xd6, 0xf0, 0x17, 0x46,
		0xba, 0xe5, 0x6b, 0xba, 0xdd, 0xd3, 0x0e, 0x75, 0xff, 0xb0, 0xb2, 0x46, 0x08, 0xea, 0xe9, 0x4a,
		0x4a, 0x3d, 0x43, 0x14, 0xb7, 0xb9, 0x9e, 0x42, 0xd5, 0x6a, 0x76, 0xef, 0xb3, 0xba, 0x7f, 0x88,
		0x64, 0x38, 0x45, 0x59, 0xfc, 0xc0, 0x33, 0xed, 0x81, 0x66, 0x1c, 0x62, 0xe3, 0xb6, 0x36, 0x0a,
		0xfa, 0xcf, 0x57, 0x1e, 0x89, 0x8e, 0x4f, 0x67, 0xd8, 0xa1, 0x3a, 0x0d, 0xa2, 0xb2, 0x1f, 0xf4,
		0x9f, 0x47, 0x1d, 0x28, 0x91, 0xcd, 0x18, 0x9a, 0xf7, 0xb0, 0xd6, 0x77, 0x3c, 0x9a, 0x1a, 0xcb,
		0x33, 0x42, 0x53, 0xc4, 0x82, 0x9b, 0x2d, 0x0e, 0xd8, 0x75, 0x7a, 0x58, 0xce, 0x75, 0xda, 0x8a,
		0xb2, 0xa5, 0x16, 0x05, 0xcb, 0x0d, 0xc7, 0x23, 0x0e, 0x35, 0x70, 0x42, 0x03, 0x17, 0x99, 0x43,
		0x0d, 0x1c, 0x61, 0xde, 0x2b, 0xb0, 0x6a, 0x18, 0x6c, 0xcd, 0xa6, 0xa1, 0xf1, 0x3b, 0x96, 0x5f,
		0x91, 0x62, 0xc6, 0x32, 0x8c, 0x6d, 0xa6, 0xc0, 0x7d, 0xdc, 0x47, 0xd7, 0xe0, 0xe1, 0xb1, 0xb1,
		0xa2, 0xc0, 0x95, 0xa9, 0x55, 0x4e, 0x42, 0xaf, 0xc0, 0xaa, 0x7b, 0x34, 0x0d, 0x44, 0xb1, 0x11,
		0xdd, 0xa3, 0x49, 0xd8, 0x73, 0xb0, 0xe6, 0x1e, 0xba, 0xd3, 0xb8, 0xa7, 0xa2, 0x38, 0xe4, 0x1e,
		0xba, 0x93, 0xc0, 0x27, 0xe9, 0x85, 0xdb, 0xc3, 0x86, 0x1e, 0xe0, 0x5e, 0xe5, 0x74, 0x54, 0x3d,
		0xd2, 0x81, 0x2e, 0x81, 0x64, 0x18, 0x1a, 0xb6, 0xf5, 0x03, 0x0b, 0x6b, 0xba, 0x87, 0x6d, 0xdd,
		0xaf, 0x9c, 0x8d, 0x2a, 0x97, 0x0d, 0x43, 0xa1, 0xbd, 0x35, 0xda, 0x89, 0x9e, 0x82, 0x15, 0xe7,
		0xe0, 0x96, 0xc1, 0x5c, 0x52, 0x73, 0x3d, 0xdc, 0x37, 0x5f, 0xaf, 0x3c, 0x41, 0xed, 0xbb, 0x4c,
		0x3a, 0xa8, 0x43, 0xb6, 0xa9, 0x18, 0x5d, 0x04, 0xc9, 0xf0, 0x0f, 0x75, 0xcf, 0xa5, 0x31, 0xd9,
		0x77, 0x75, 0x03, 0x57, 0x9e, 0x64, 0xaa, 0x4c, 0xbe, 0x27, 0xc4, 0xe4, 0x48, 0xf8, 0x77, 0xcd,
		0x7e, 0x20, 0x18, 0x2f, 0xb0, 0x23, 0x41, 0x65, 0x9c, 0x6d, 0x03, 0x24, 0x62, 0x8a, 0xd8, 0xc0,
		0x1b, 0x54, 0xad, 0xec, 0x1e, 0xba, 0xd1, 0x71, 0x1f, 0x87, 0x25, 0xa2, 0x39, 0x1e, 0xf4, 0x22,
		0x2b, 0xc8, 0xdc, 0xc3, 0xc8, 0x88, 0x1f, 0x5a, 0x6d, 0x5c, 0x95, 0xa1, 0x14, 0xf5, 0x4f, 0x54,
		0x00, 0xe6, 0xa1, 0x52, 0x8a, 0x14, 0x2b, 0x8d, 0xd6, 0x16, 0x29, 0x33, 0x5e, 0x53, 0xa4, 0x34,
		0x29, 0x77, 0x76, 0x9a, 0x5d, 0x45, 0x53, 0xf7, 0xf7, 0xba, 0xcd, 0x5d, 0x45, 0xca, 0x44, 0xeb,
		0xea, 0xef, 0xa4, 0xa1, 0x1c, 0xbf, 0x22, 0xa1, 0x1f, 0x81, 0xd3, 0xe2, 0x3d, 0xc3, 0xc7, 0x81,
		0x76, 0xd7, 0xf4, 0xe8, 0x91, 0x19, 0xea, 0x2c, 0x7d, 0x85, 0x9b, 0xb6, 0xc6, 0xb5, 0x3a, 0x38,
		0x78, 0xd9, 0xf4, 0xc8, 0x81, 0x18, 0xea, 0x01, 0xda, 0x81, 0xb3, 0xb6, 0xa3, 0xf9, 0x81, 0x6e,
		0xf7, 0x74, 0xaf, 0xa7, 0x8d, 0x5f, 0x92, 0x34, 0xdd, 0x30, 0xb0, 0xef, 0x3b, 0x2c, 0x55, 0x85,
		0x2c, 0x1f, 0xb3, 0x9d, 0x0e, 0x57, 0x1e, 0xc7, 0xf0, 0x1a, 0x57, 0x9d, 0x70, 0xb0, 0xcc, 0x71,
		0x0e, 0xf6, 0x08, 0x14, 0x86, 0xba, 0xab, 0x61, 0x3b, 0xf0, 0x8e, 0x68, 0x61, 0x9c, 0x57, 0xf3,
		0x43, 0xdd, 0x55, 0x48, 0xfb, 0xa3, 0xb9, 0x9f, 0xfc, 0x7d, 0x06, 0x4a, 0xd1, 0xe2, 0x98, 0xdc,
		0x35, 0x0c, 0x9a, 0x47, 0x52, 0x34, 0xd2, 0x3c, 0xfe, 0xc0, 0x52, 0x7a, 0xb3, 0x41, 0x12, 0x8c,
		0xbc, 0xc0, 0x4a, 0x56, 0x95, 0x21, 0x49, 0x72, 0x27, 0xb1, 0x05, 0xb3, 0x12, 0x21, 0xaf, 0xf2,
		0x16, 0xda, 0x86, 0x85, 0x5b, 0x3e, 0xe5, 0x5e, 0xa0, 0xdc, 0x4f, 0x3c, 0x98, 0xfb, 0x66, 0x87,
		0x92, 0x17, 0x6e, 0x76, 0xb4, 0xbd, 0x96, 0xba, 0x5b, 0xdb, 0x51, 0x39, 0x1c, 0x9d, 0x81, 0xac,
		0xa5, 0xdf, 0x3b, 0x8a, 0xa7, 0x22, 0x2a, 0x9a, 0xd7, 0xf0, 0x67, 0x20, 0x7b, 0x17, 0xeb, 0xb7,
		0xe3, 0x09, 0x80, 0x8a, 0x3e, 0x44, 0xd7, 0xbf, 0x04, 0x39, 0x6a, 0x2f, 0x04, 0xc0, 0x2d, 0x26,
		0x3d, 0x84, 0xf2, 0x90, 0x6d, 0xb4, 0x54, 0xe2, 0xfe, 0x12, 0x94, 0x98, 0x54, 0x6b, 0x37, 0x95,
		0x86, 0x22, 0xa5, 0xab, 0x57, 0x60, 0x81, 0x19, 0x81, 0x1c, 0x8d, 0xd0, 0x0c, 0xd2, 0x43, 0xbc,
		0xc9, 0x39, 0x52, 0xa2, 0x77, 0x7f, 0xb7, 0xae, 0xa8, 0x52, 0x3a, 0xba, 0xbd, 0x3e, 0x94, 0xa2,
		0x75, 0xf1, 0x47, 0xe3, 0x53, 0x7f, 0x99, 0x82, 0x62, 0xa4, 0xce, 0x25, 0x05, 0x8a, 0x6e, 0x59,
		0xce, 0x5d, 0x4d, 0xb7, 0x4c, 0xdd, 0xe7, 0x4e, 0x01, 0x54, 0x54, 0x23, 0x92, 0x79, 0x37, 0xed,
		0x23, 0x99, 0xfc, 0x3b, 0x29, 0x90, 0x26, 0x4b, 0xcc, 0x89, 0x09, 0xa6, 0x7e, 0xa8, 0x13, 0x7c,
		0x3b, 0x05, 0xe5, 0x78, 0x5d, 0x39, 0x31, 0xbd, 0xf3, 0x3f, 0xd4, 0xe9, 0xfd, 0x43, 0x1a, 0x96,
		0x62, 0xd5, 0xe4, 0xbc, 0xb3, 0xfb, 0x02, 0xac, 0x98, 0x3d, 0x3c, 0x74, 0x9d, 0x00, 0xdb, 0xc6,
		0x91, 0x66, 0xe1, 0x3b, 0xd8, 0xaa, 0x54, 0x69, 0xa0, 0xb8, 0xf4, 0xe0, 0x7a, 0x75, 0xb3, 0x39,
		0xc6, 0xed, 0x10, 0x98, 0xbc, 0xda, 0xdc, 0x52, 0x76, 0xdb, 0xad, 0xae, 0xb2, 0xd7, 0x78, 0x55,
		0xdb, 0xdf, 0x7b, 0x71, 0xaf, 0xf5, 0xf2, 0x9e, 0x2a, 0x99, 0x13, 0x6a, 0x1f, 0xe2, 0x51, 0x6f,
		0x83, 0x34, 0x39, 0x29, 0x74, 0x1a, 0x66, 0x4d, 0x4b, 0x7a, 0x08, 0xad, 0xc2, 0xf2, 0x5e, 0x4b,
		0xeb, 0x34, 0xb7, 0x14, 0x4d, 0xb9, 0x71, 0x43, 0x69, 0x74, 0x3b, 0xec, 0x05, 0x22, 0xd4, 0xee,
		0xc6, 0x0f, 0xf5, 0x5b, 0x19, 0x58, 0x9d, 0x31, 0x13, 0x54, 0xe3, 0x77, 0x07, 0x76, 0x9d, 0xf9,
		0xe4, 0x3c, 0xb3, 0xdf, 0x24, 0x29, 0xbf, 0xad, 0x7b, 0x01, 0xbf, 0x6a, 0x5c, 0x04, 0x62, 0x25,
		0x3b, 0x30, 0xfb, 0x26, 0xf6, 0xf8, 0x83, 0x0d, 0xbb, 0x50, 0x2c, 0x8f, 0xe5, 0xec, 0xcd, 0xe6,
		0x13, 0x80, 0x5c, 0xc7, 0x37, 0x03, 0xf3, 0x0e, 0xd6, 0x4c, 0x5b, 0xbc, 0xee, 0x90, 0x0b, 0x46,
		0x56, 0x95, 0x44, 0x4f, 0xd3, 0x0e, 0x42, 0x6d, 0x1b, 0x0f, 0xf4, 0x09, 0x6d, 0x12, 0xc0, 0x33,
		0xaa, 0x24, 0x7a, 0x42, 0xed, 0xf3, 0x50, 0xea, 0x39, 0x23, 0x52, 0x75, 0x31, 0x3d, 0x92, 0x2f,
		0x52, 0x6a, 0x91, 0xc9, 0x42, 0x15, 0x5e, 0x4f, 0x8f, 0x9f, 0x95, 0x4a, 0x6a, 0x91, 0xc9, 0x98,
		0xca, 0x05, 0x58, 0xd6, 0x07, 0x03, 0x8f, 0x90, 0x0b, 0x22, 0x76, 0x43, 0x28, 0x87, 0x62, 0xaa,
		0xb8, 0x7e, 0x13, 0xf2, 0xc2, 0x0e, 0x24, 0x25, 0x13, 0x4b, 0x68, 0x2e, 0xbb, 0xf6, 0xa6, 0x37,
		0x0a, 0x6a, 0xde, 0x16, 0x9d, 0xe7, 0xa1, 0x64, 0xfa, 0xda, 0xf8, 0x95, 0x3c, 0x7d, 0x2e, 0xbd,
		0x91, 0x57, 0x8b, 0xa6, 0x1f, 0xbe, 0x30, 0x56, 0xdf, 0x4d, 0x43, 0x39, 0xfe, 0xca, 0x8f, 0xb6,
		0x20, 0x6f, 0x39, 0x86, 0x4e, 0x5d, 0x8b, 0x7d, 0x62, 0xda, 0x48, 0xf8, 0x30, 0xb0, 0xb9, 0xc3,
		0xf5, 0xd5, 0x10, 0xb9, 0xfe, 0x77, 0x29, 0xc8, 0x0b, 0x31, 0x3a, 0x05, 0x59, 0x57, 0x0f, 0x0e,
		0x29, 0x5d, 0xae, 0x9e, 0x96, 0x52, 0x2a, 0x6d, 0x13, 0xb9, 0xef, 0xea, 0x36, 0x75, 0x01, 0x2e,
		0x27, 0x6d, 0xb2, 0xaf, 0x16, 0xd6, 0x7b, 0xf4, 0xfa, 0xe1, 0x0c, 0x87, 0xd8, 0x0e, 0x7c, 0xb1,
		0xaf, 0x5c, 0xde, 0xe0, 0x62, 0xf4, 0x34, 0xac, 0x04, 0x9e, 0x6e, 0x5a, 0x31, 0xdd, 0x2c, 0xd5,
		0x95, 0x44, 0x47, 0xa8, 0x2c, 0xc3, 0x19, 0xc1, 0xdb, 0xc3, 0x81, 0x6e, 0x1c, 0xe2, 0xde, 0x18,
		0xb4, 0x40, 0x9f, 0x19, 0x4e, 0x73, 0x85, 0x2d, 0xde, 0x2f, 0xb0, 0xd5, 0xef, 0xa6, 0x60, 0x45,
		0x5c, 0x98, 0x7a, 0xa1, 0xb1, 0x76, 0x01, 0x74, 0xdb, 0x76, 0x82, 0xa8, 0xb9, 0xa6, 0x5d, 0x79,
		0x0a, 0xb7, 0x59, 0x0b, 0x41, 0x6a, 0x84, 0x60, 0x7d, 0x08, 0x30, 0xee, 0x39, 0xd6, 0x6c, 0x67,
		0xa1, 0xc8, 0x3f, 0xe1, 0xd0, 0xef, 0x80, 0xec, 0x8a, 0x0d, 0x4c, 0x44, 0x6e, 0x56, 0x68, 0x0d,
		0x72, 0x07, 0x78, 0x60, 0xda, 0xfc, 0x61, 0x96, 0x35, 0xc4, 0x43, 0x48, 0x36, 0x7c, 0x08, 0xa9,
		0x7f, 0x1e, 0x56, 0x0d, 0x67, 0x38, 0x39, 0xdd, 0xba, 0x34, 0x71, 0xcd, 0xf7, 0x3f, 0x9b, 0x7a,
		0x0d, 0xc6, 0x25, 0xe6, 0xff, 0xa5, 0x52, 0xbf, 0x95, 0xce, 0x6c, 0xb7, 0xeb, 0x5f, 0x4f, 0xaf,
		0x6f, 0x33, 0x68, 0x5b, 0xac, 0x54, 0xc5, 0x7d, 0x0b, 0x1b, 0x64, 0xf6, 0xf0, 0xa5, 0x0b, 0xf0,
		0xc9, 0x81, 0x19, 0x1c, 0x8e, 0x0e, 0x36, 0x0d, 0x67, 0x78, 0x69, 0xe0, 0x0c, 0x9c, 0xf1, 0xa7,
		0x4f, 0xd2, 0xa2, 0x0d, 0xfa, 0x1f, 0xff, 0xfc, 0x59, 0x08, 0xa5, 0xeb, 0x89, 0xdf, 0x4a, 0xe5,
		0x3d, 0x58, 0xe5, 0xca, 0x1a, 0xfd, 0xfe, 0xc2, 0x6e, 0x11, 0xe8, 0x81, 0x6f, 0x58, 0x95, 0x6f,
		0xbe, 0x47, 0xd3, 0xb5, 0xba, 0xc2, 0xa1, 0xa4, 0x8f, 0x5d, 0x34, 0x64, 0x15, 0x1e, 0x8e, 0xf1,
		0xb1, 0xa3, 0x89, 0xbd, 0x04, 0xc6, 0xef, 0x70, 0xc6, 0xd5, 0x08, 0x63, 0x87, 0x43, 0xe5, 0x06,
		0x2c, 0x9d, 0x84, 0xeb, 0xaf, 0x39, 0x57, 0x09, 0x47, 0x49, 0xb6, 0x61, 0x99, 0x92, 0x18, 0x23,
		0x3f, 0x70, 0x86, 0x34, 0xee, 0x3d, 0x98, 0xe6, 0x6f, 0xde, 0x63, 0x67, 0xa5, 0x4c, 0x60, 0x8d,
		0x10, 0x25, 0xcb, 0x40, 0x3f, 0x39, 0xf5, 0xb0, 0x61, 0x25, 0x30, 0xfc, 0x2d, 0x9f, 0x48, 0xa8,
		0x2f, 0xbf, 0x04, 0x6b, 0xe4, 0x7f, 0x1a, 0x96, 0xa2, 0x33, 0x49, 0x7e, 0xf0, 0xaa, 0x7c, 0xf7,
		0x4d, 0x76, 0x1c, 0x57, 0x43, 0x82, 0xc8, 0x9c, 0x22, 0xbb, 0x38, 0xc0, 0x41, 0x80, 0x3d, 0x5f,
		0xd3, 0xad, 0x59, 0xd3, 0x8b, 0xbc, 0x18, 0x54, 0xbe, 0xf2, 0x7e, 0x7c, 0x17, 0xb7, 0x19, 0xb2,
		0x66, 0x59, 0xf2, 0x3e, 0x9c, 0x9e, 0xe1, 0x15, 0x73, 0x70, 0xbe, 0xc5, 0x39, 0xd7, 0xa6, 0x3c,
		0x83, 0xd0, 0xb6, 0x41, 0xc8, 0xc3, 0xbd, 0x9c, 0x83, 0xf3, 0xd7, 0x38, 0x27, 0xe2, 0x58, 0xb1,
		0xa5, 0x84, 0xf1, 0x26, 0xac, 0xdc, 0xc1, 0xde, 0x81, 0xe3, 0xf3, 0x57, 0x9a, 0x39, 0xe8, 0xde,
		0xe6, 0x74, 0xcb, 0x1c, 0x48, 0x9f, 0x6d, 0x08, 0xd7, 0x35, 0xc8, 0xf7, 0x75, 0x03, 0xcf, 0x41,
		0xf1, 0x55, 0x4e, 0xb1, 0x48, 0xf4, 0x09, 0xb4, 0x06, 0xa5, 0x81, 0xc3, 0x33, 0x53, 0x32, 0xfc,
		0x1d, 0x0e, 0x2f, 0x0a, 0x0c, 0xa7, 0x70, 0x1d, 0x77, 0x64, 0x91, 0xb4, 0x95, 0x4c, 0xf1, 0xeb,
		0x82, 0x42, 0x60, 0x38, 0xc5, 0x09, 0xcc, 0xfa, 0x1b, 0x82, 0xc2, 0x8f, 0xd8, 0xf3, 0x05, 0x28,
		0x3a, 0xb6, 0x75, 0xe4, 0xd8, 0xf3, 0x4c, 0xe2, 0x37, 0x39, 0x03, 0x70, 0x08, 0x21, 0xb8, 0x0e,
		0x85, 0x79, 0x37, 0xe2, 0x6b, 0xef, 0x8b, 0xe3, 0x21, 0x76, 0x60, 0x1b, 0x96, 0x45, 0x80, 0x32,
		0x1d, 0x7b, 0x0e, 0x8a, 0xdf, 0xe6, 0x14, 0xe5, 0x08, 0x8c, 0x2f, 0x23, 0xc0, 0x7e, 0x30, 0xc0,
		0xf3, 0x90, 0xbc, 0x2b, 0x96, 0xc1, 0x21, 0xdc, 0x94, 0x07, 0xd8, 0x36, 0x0e, 0xe7, 0x63, 0xf8,
		0x1d, 0x61, 0x4a, 0x81, 0x21, 0x14, 0x0d, 0x58, 0x1a, 0xea, 0x9e, 0x7f, 0xa8, 0x5b, 0x73, 0x6d,
		0xc7, 0xef, 0x72, 0x8e, 0x52, 0x08, 0xe2, 0x16, 0x19, 0xd9, 0x27, 0xa1, 0xf9, 0xba, 0xb0, 0x48,
		0x04, 0xc6, 0x8f, 0x9e, 0x1f, 0xd0, 0x27, 0xad, 0x93, 0xb0, 0xfd, 0x9e, 0x38, 0x7a, 0x0c, 0xbb,
		0x1b, 0x65, 0xbc, 0x0e, 0x05, 0xdf, 0xbc, 0x37, 0x17, 0xcd, 0xef, 0x8b, 0x9d, 0xa6, 0x00, 0x02,
		0x7e, 0x15, 0xce, 0xcc, 0x4c, 0x13, 0x73, 0x90, 0xfd, 0x01, 0x27, 0x3b, 0x35, 0x23, 0x55, 0xf0,
		0x90, 0x70, 0x52, 0xca, 0x3f, 0x14, 0x21, 0x01, 0x4f, 0x70, 0xb5, 0xc9, 0x5d, 0xc1, 0xd7, 0xfb,
		0x27, 0xb3, 0xda, 0x1f, 0x09, 0xab, 0x31, 0x6c, 0xcc, 0x6a, 0x5d, 0x38, 0xc5, 0x19, 0x4f, 0xb6,
		0xaf, 0xdf, 0x10, 0x81, 0x95, 0xa1, 0xf7, 0xe3, 0xbb, 0xfb, 0x79, 0x58, 0x0f, 0xcd, 0x29, 0x8a,
		0x52, 0x5f, 0x1b, 0xea, 0xee, 0x1c, 0xcc, 0xdf, 0xe4, 0xcc, 0x22, 0xe2, 0x87, 0x55, 0xad, 0xbf,
		0xab, 0xbb, 0x84, 0xfc, 0x15, 0xa8, 0x08, 0xf2, 0x91, 0xed, 0x61, 0xc3, 0x19, 0xd8, 0xe6, 0x3d,
		0xdc, 0x9b, 0x83, 0xfa, 0x8f, 0x27, 0xb6, 0x6a, 0x3f, 0x02, 0x27, 0xcc, 0x4d, 0x90, 0xc2, 0x5a,
		0x45, 0x33, 0x87, 0xae, 0xe3, 0x05, 0x09, 0x8c, 0xdf, 0x12, 0x3b, 0x15, 0xe2, 0x9a, 0x14, 0x26,
		0x2b, 0x50, 0xa6, 0xcd, 0x79, 0x5d, 0xf2, 0x4f, 0x38, 0xd1, 0xd2, 0x18, 0xc5, 0x03, 0x87, 0xe1,
		0x0c, 0x5d, 0xdd, 0x9b, 0x27, 0xfe, 0xfd, 0xa9, 0x08, 0x1c, 0x1c, 0xc2, 0x03, 0x47, 0x70, 0xe4,
		0x62, 0x92, 0xed, 0xe7, 0x60, 0xf8, 0xb6, 0x08, 0x1c, 0x02, 0xc3, 0x29, 0x44, 0xc1, 0x30, 0x07,
		0xc5, 0x9f, 0x09, 0x0a, 0x81, 0x21, 0x14, 0x9f, 0x1b, 0x27, 0x5a, 0x0f, 0x0f, 0x4c, 0x3f, 0xf0,
		0x58, 0x29, 0xfc, 0x60, 0xaa, 0x3f, 0x7f, 0x3f, 0x5e, 0x84, 0xa9, 0x11, 0xa8, 0x7c, 0x13, 0x96,
		0x27, 0x4a, 0x0c, 0x94, 0xf4, 0xfb, 0x95, 0xca, 0x4f, 0x7c, 0xc0, 0x83, 0x51, 0xbc, 0xc2, 0x90,
		0x77, 0xc8, 0xbe, 0xc7, 0xeb, 0x80, 0x64, 0xb2, 0x37, 0x3f, 0x08, 0xb7, 0x3e, 0x56, 0x06, 0xc8,
		0x37, 0x60, 0x29, 0x56, 0x03, 0x24, 0x53, 0xfd, 0x24, 0xa7, 0x2a, 0x45, 0x4b, 0x00, 0xf9, 0x0a,
		0x64, 0x49, 0x3e, 0x4f, 0x86, 0xff, 0x14, 0x87, 0x53, 0x75, 0xf9, 0xd3, 0x90, 0x17, 0x79, 0x3c,
		0x19, 0xfa, 0xd3, 0x1c, 0x1a, 0x42, 0x08, 0x5c, 0xe4, 0xf0, 0x64, 0xf8, 0xcf, 0x08, 0xb8, 0x80,
		0x10, 0xf8, 0xfc, 0x26, 0xfc, 0xab, 0x9f, 0xcd, 0xf2, 0x38, 0x2c, 0x6c, 0x77, 0x1d, 0x16, 0x79,
		0xf2, 0x4e, 0x46, 0x7f, 0x91, 0x0f, 0x2e, 0x10, 0xf2, 0x73, 0x90, 0x9b, 0xd3, 0xe0, 0x3f, 0xc7,
		0xa1, 0x4c, 0x5f, 0x6e, 0x40, 0x31, 0x92, 0xb0, 0x93, 0xe1, 0x3f, 0xcf, 0xe1, 0x51, 0x14, 0x99,
		0x3a, 0x4f, 0xd8, 0xc9, 0x04, 0xbf, 0x20, 0xa6, 0xce, 0x11, 0xc4, 0x6c, 0x22, 0x57, 0x27, 0xa3,
		0x7f, 0x51, 0x58, 0x5d, 0x40, 0xe4, 0x17, 0xa0, 0x10, 0xc6, 0xdf, 0x64, 0xfc, 0x2f, 0x71, 0xfc,
		0x18, 0x43, 0x2c, 0x10, 0x89, 0xff, 0xc9, 0x14, 0xbf, 0x2c, 0x2c, 0x10, 0x41, 0x91, 0x63, 0x34,
		0x99, 0xd3, 0x93, 0x99, 0x7e, 0x45, 0x1c, 0xa3, 0x89, 0x94, 0x4e, 0x76, 0x93, 0x86, 0xc1, 0x64,
		0x8a, 0x5f, 0x15, 0xbb, 0x49, 0xf5, 0xc9, 0x34, 0x26, 0x93, 0x64, 0x32, 0xc7, 0x97, 0xc4, 0x34,
		0x26, 0x72, 0xa4, 0xdc, 0x06, 0x34, 0x9d, 0x20, 0x93, 0xf9, 0xbe, 0xcc, 0xf9, 0x56, 0xa6, 0xf2,
		0xa3, 0xfc, 0x32, 0x9c, 0x9a, 0x9d, 0x1c, 0x93, 0x59, 0xbf, 0xf2, 0xc1, 0xc4, 0x75, 0x26, 0x9a,
		0x1b, 0xe5, 0xee, 0x38, 0xca, 0x46, 0x13, 0x63, 0x32, 0xed, 0x5b, 0x1f, 0xc4, 0x03, 0x6d, 0x34,
		0x2f, 0xca, 0x35, 0x80, 0x71, 0x4e, 0x4a, 0xe6, 0x7a, 0x9b, 0x73, 0x45, 0x40, 0xe4, 0x68, 0xf0,
		0x94, 0x94, 0x8c, 0xff, 0xaa, 0x38, 0x1a, 0x1c, 0x41, 0x8e, 0x86, 0xc8, 0x46, 0xc9, 0xe8, 0x77,
		0xc4, 0xd1, 0x10, 0x10, 0xf9, 0x3a, 0xe4, 0xed, 0x91, 0x65, 0x11, 0xdf, 0x42, 0x0f, 0xfe, 0x49,
		0x56, 0xe5, 0xdf, 0xee, 0x73, 0xb0, 0x00, 0xc8, 0x57, 0x20, 0x87, 0x87, 0x07, 0xb8, 0x97, 0x84,
		0xfc, 0xf7, 0xfb, 0x22, 0x9e, 0x10, 0x6d, 0xf9, 0x05, 0x00, 0x76, 0x99, 0xa6, 0x1f, 0x8a, 0x12,
		0xb0, 0xff, 0x71, 0x9f, 0xff, 0x58, 0x62, 0x0c, 0x19, 0x13, 0xb0, 0x9f, 0x5e, 0x3c, 0x98, 0xe0,
		0xfd, 0x38, 0x01, 0xbd, 0x80, 0x5f, 0x83, 0xc5, 0x5b, 0xbe, 0x63, 0x07, 0xfa, 0x20, 0x09, 0xfd,
		0x9f, 0x1c, 0x2d, 0xf4, 0x89, 0xc1, 0x86, 0x8e, 0x87, 0x03, 0x7d, 0xe0, 0x27, 0x61, 0xff, 0x8b,
		0x63, 0x43, 0x00, 0x01, 0x1b, 0xba, 0x1f, 0xcc, 0xb3, 0xee, 0xef, 0x09, 0xb0, 0x00, 0x90, 0x49,
		0x93, 0xff, 0x6f, 0xe3, 0xa3, 0x24, 0xec, 0xf7, 0xc5, 0xa4, 0xb9, 0xbe, 0xfc, 0x69, 0x28, 0x90,
		0x7f, 0xd9, 0x2f, 0xa0, 0x12, 0xc0, 0xff, 0xcd, 0xc1, 0x63, 0x04, 0x19, 0xd9, 0x0f, 0x7a, 0x81,
		0x99, 0x6c, 0xec, 0xff, 0xe1, 0x3b, 0x2d, 0xf4, 0xe5, 0x1a, 0x14, 0xfd, 0xa0, 0xd7, 0x1b, 0xf1,
		0x8a, 0x26, 0x01, 0xfe, 0xbf, 0xf7, 0xc3, 0x4b, 0x6e, 0x88, 0xa9, 0x2b, 0xb3, 0xdf, 0xeb, 0x60,
		0xdb, 0xd9, 0x76, 0xd8, 0x4b, 0xdd, 0x6b, 0xd5, 0xe4, 0x27, 0x37, 0xf8, 0x5a, 0x96, 0xd7, 0x9c,
		0xf6, 0x68, 0xc8, 0x9f, 0xde, 0xf2, 0xa2, 0xbd, 0x7e, 0xb2, 0x37, 0xbb, 0xaa, 0x0c, 0x79, 0x3a,
		0xf2, 0xde, 0x68, 0x88, 0x36, 0x21, 0xff, 0x22, 0x3e, 0x7a, 0x29, 0xf2, 0xa3, 0x34, 0xb4, 0x19,
		0x8e, 0x23, 0x7a, 0xd4, 0x50, 0xa7, 0x7a, 0x79, 0xac, 0x8f, 0x24, 0xc8, 0xbc, 0x88, 0x8f, 0xf8,
		0xcf, 0x67, 0xc8, 0xbf, 0x68, 0x0d, 0x72, 0x82, 0x8a, 0xc8, 0x58, 0xa3, 0xfa, 0x1a, 0x40, 0xd7,
		0x71, 0xfd, 0xa3, 0xee, 0xc8, 0xbb, 0x73, 0x84, 0x9e, 0x84, 0x1c, 0x6d, 0x51, 0x5c, 0xf1, 0xf2,
		0xf2, 0x78, 0x38, 0x2a, 0x56, 0x59, 0x2f, 0x55, 0x23, 0xfa, 0xfc, 0xd7, 0x78, 0x51, 0x35, 0x22,
		0x56, 0x59, 0x6f, 0xf5, 0x71, 0xce, 0x86, 0x4a, 0x90, 0xaa, 0x51, 0xca, 0x8c, 0x9a, 0xaa, 0x91,
		0x56, 0x9d, 0x22, 0x33, 0x6a, 0xaa, 0x4e, 0x95, 0xe8, 0xd8, 0x54, 0xcc, 0x95, 0xea, 0x0c, 0xc2,
		0x95, 0x6a, 0xd5, 0x11, 0x64, 0x5f, 0xb4, 0x9d, 0x00, 0x5d, 0x84, 0x5c, 0xdd, 0x1c, 0x1c, 0x06,
		0xfc, 0x65, 0x78, 0x75, 0x3c, 0x30, 0x15, 0x13, 0x1d, 0x95, 0x69, 0x90, 0xe5, 0x2a, 0xd6, 0x81,
		0x73, 0x97, 0x7f, 0x70, 0x64, 0x0d, 0xf4, 0x09, 0x28, 0xd4, 0x4d, 0x52, 0x7b, 0x2a, 0x76, 0x8f,
		0xff, 0x6e, 0xab, 0x1c, 0xb1, 0x29, 0xc1, 0x8f, 0x15, 0xaa, 0x0d, 0xa2, 0xcd, 0x79, 0x51, 0x15,
		0xb2, 0x3b, 0x8e, 0xe3, 0x72, 0xd3, 0x4c, 0xa2, 0x68, 0x1f, 0x42, 0x90, 0xed, 0x8e, 0x3c, 0x9b,
		0x8f, 0x49, 0xff, 0xaf, 0xe7, 0xbf, 0xff, 0x8f, 0x8f, 0xa5, 0xbe, 0xf1, 0x4f, 0x8f, 0xa5, 0xfe,
		0x3f, 0x00, 0x00, 0xff, 0xff, 0xd2, 0x40, 0xc2, 0xe3, 0xb4, 0x32, 0x00, 0x00,
	}
	r := bytes.NewReader(gzipped)
	gzipr, err := gzip.NewReader(r)
	if err != nil {
		panic(err)
	}
	ungzipped, err := ioutil.ReadAll(gzipr)
	if err != nil {
		panic(err)
	}
	if err := proto.Unmarshal(ungzipped, d); err != nil {
		panic(err)
	}
	return d
}
func (this *ProtoNum) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&protonum.ProtoNum{")
	if this.KeyValue != nil {
		s = append(s, "KeyValue: "+fmt.Sprintf("%#v", this.KeyValue)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *KeyValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&protonum.KeyValue{")
	if this.Key != nil {
		s = append(s, "Key: "+valueToGoStringProtonum(this.Key, "string")+",\n")
	}
	if this.Value != nil {
		s = append(s, "Value: "+valueToGoStringProtonum(this.Value, "string")+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TopsyTurvy) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&protonum.TopsyTurvy{")
	if this.Topsy != nil {
		s = append(s, "Topsy: "+fmt.Sprintf("%#v", this.Topsy)+",\n")
	}
	if this.Turvy != nil {
		s = append(s, "Turvy: "+fmt.Sprintf("%#v", this.Turvy)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Topsy) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&protonum.Topsy{")
	if this.A != nil {
		s = append(s, "A: "+valueToGoStringProtonum(this.A, "int64")+",\n")
	}
	if this.B != nil {
		s = append(s, "B: "+valueToGoStringProtonum(this.B, "int64")+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Turvy) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&protonum.Turvy{")
	if this.B != nil {
		s = append(s, "B: "+valueToGoStringProtonum(this.B, "int64")+",\n")
	}
	if this.A != nil {
		s = append(s, "A: "+valueToGoStringProtonum(this.A, "int64")+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Knot) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&protonum.Knot{")
	if this.Bight != nil {
		s = append(s, "Bight: "+fmt.Sprintf("%#v", this.Bight)+",\n")
	}
	if this.Elbow != nil {
		s = append(s, "Elbow: "+valueToGoStringProtonum(this.Elbow, "bool")+",\n")
	}
	if this.BitterEnd != nil {
		s = append(s, "BitterEnd: "+fmt.Sprintf("%#v", this.BitterEnd)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BightKnot) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&protonum.BightKnot{")
	if this.Loop != nil {
		s = append(s, "Loop: "+fmt.Sprintf("%#v", this.Loop)+",\n")
	}
	if this.Turn != nil {
		s = append(s, "Turn: "+valueToGoStringProtonum(this.Turn, "bool")+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringProtonum(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 init() { proto.RegisterFile("protonum.proto", fileDescriptorProtonum) }

var fileDescriptorProtonum = []byte{
	// 317 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x90, 0xc1, 0x4a, 0xc3, 0x40,
	0x10, 0x86, 0x59, 0xd3, 0x42, 0x3a, 0x95, 0x2a, 0xa3, 0x87, 0xe0, 0xa1, 0x94, 0x15, 0xa1, 0x82,
	0xa6, 0xd0, 0xa3, 0xb7, 0xae, 0xf4, 0x54, 0x11, 0x59, 0x8a, 0x07, 0x6f, 0x46, 0x63, 0x1a, 0x68,
	0xb2, 0x21, 0xee, 0x2a, 0x79, 0x2b, 0x5f, 0x49, 0x9f, 0xc0, 0x47, 0x90, 0x9d, 0xdd, 0x34, 0xea,
	0x6d, 0xfe, 0x99, 0xef, 0xff, 0xff, 0x64, 0x61, 0x54, 0xd5, 0x4a, 0xab, 0xd2, 0x14, 0x31, 0x0d,
	0x18, 0xb6, 0xfa, 0xe4, 0x32, 0xcb, 0xf5, 0xc6, 0x24, 0xf1, 0x93, 0x2a, 0x66, 0x99, 0xca, 0xd4,
	0x8c, 0x2e, 0x89, 0x79, 0x21, 0x45, 0x82, 0x26, 0x67, 0xe4, 0x57, 0x10, 0xde, 0xd9, 0xe1, 0xd6,
	0x14, 0x18, 0x43, 0xb8, 0x4a, 0x9b, 0xfb, 0xc7, 0xad, 0x49, 0xa3, 0xbd, 0x49, 0x30, 0x1d, 0xce,
	0x31, 0xde, 0xf5, 0xb4, 0x17, 0xb9, 0x63, 0xf8, 0xbc, 0xe3, 0xf1, 0x10, 0x82, 0x55, 0xda, 0x44,
	0x6c, 0xc2, 0xa6, 0x03, 0x69, 0x47, 0x3c, 0x86, 0x7e, 0x1b, 0x65, 0x77, 0x4e, 0xf0, 0x07, 0x80,
	0xb5, 0xaa, 0x5e, 0x9b, 0xb5, 0xa9, 0xdf, 0x1a, 0x3c, 0x83, 0x3e, 0x29, 0xf2, 0x0d, 0xe7, 0x07,
	0x5d, 0x1d, 0xad, 0xa5, 0xbb, 0x12, 0x66, 0x79, 0x8a, 0xfa, 0x8b, 0xd9, 0xb5, 0x74, 0x57, 0x7e,
	0xea, 0xd3, 0x70, 0x1f, 0xd8, 0x82, 0x22, 0x03, 0xc9, 0x16, 0x56, 0x09, 0x72, 0x06, 0x92, 0x09,
	0x82, 0xa8, 0x9b, 0xd6, 0x1e, 0x12, 0xce, 0xe2, 0xa1, 0x05, 0x37, 0xd0, 0x5b, 0x95, 0x4a, 0xe3,
	0x39, 0xf4, 0x45, 0x9e, 0x6d, 0x74, 0xc4, 0xe8, 0x39, 0x8e, 0xba, 0x62, 0x5a, 0x5b, 0x46, 0x3a,
	0xc2, 0xfe, 0xee, 0x72, 0x9b, 0xa8, 0x77, 0x0a, 0x09, 0xa5, 0x13, 0x78, 0x01, 0x03, 0x91, 0x6b,
	0x9d, 0xd6, 0xcb, 0xf2, 0x39, 0x0a, 0xe8, 0xeb, 0x47, 0xbf, 0xde, 0xd4, 0xfa, 0x3b, 0x80, 0x5f,
	0x5b, 0xda, 0xe7, 0x22, 0x87, 0xde, 0x8d, 0x52, 0x95, 0x7f, 0x9a, 0xff, 0x2e, 0xba, 0x21, 0x42,
	0x6f, 0x6d, 0xea, 0xd2, 0x77, 0xd2, 0x2c, 0xc2, 0xef, 0xcf, 0x31, 0xfb, 0xf8, 0x1a, 0xb3, 0x9f,
	0x00, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xec, 0x74, 0x43, 0x25, 0x02, 0x00, 0x00,
}

repository: lixingwang/katydid

repo_name: lixingwang/katydid