text:
package graphics

import (
	"github.com/mokiat/gomath/dprec"
	"github.com/mokiat/gomath/sprec"
	"github.com/mokiat/lacking/util/blob"
)

func newNode() Node {
	matrixData := make([]byte, 64)
	plotter := blob.NewPlotter(matrixData)
	plotter.PlotSPMat4(sprec.IdentityMat4())
	return Node{
		matrixData: matrixData,
	}
}

// Node represents a positioning of some entity in
// the 3D scene.
type Node struct {
	matrixData []byte
}

// SetMatrix changes the model matrix of this node.
// Keep in mind that this is a somewhat slow operation and should only
// be performed only once per frame. This is also the reason why there is
// no getter for this method. Clients are expected to track matrices outside
// this type if needed.
func (n *Node) SetMatrix(matrix dprec.Mat4) {
	plotter := blob.NewPlotter(n.matrixData)
	// plotter.PlotMat4(dtos.Mat4(matrix))
	plotter.PlotFloat32(float32(matrix.M11))
	plotter.PlotFloat32(float32(matrix.M21))
	plotter.PlotFloat32(float32(matrix.M31))
	plotter.Skip(4) // skip matrix.M41 (assume unchanged)
	plotter.PlotFloat32(float32(matrix.M12))
	plotter.PlotFloat32(float32(matrix.M22))
	plotter.PlotFloat32(float32(matrix.M32))
	plotter.Skip(4) // skip matrix.M42 (assume unchanged)
	plotter.PlotFloat32(float32(matrix.M13))
	plotter.PlotFloat32(float32(matrix.M23))
	plotter.PlotFloat32(float32(matrix.M33))
	plotter.Skip(4) // skip matrix.M43 (assume unchanged)
	plotter.PlotFloat32(float32(matrix.M14))
	plotter.PlotFloat32(float32(matrix.M24))
	plotter.PlotFloat32(float32(matrix.M34))
	plotter.Skip(4) // skip matrix.M44 (assume unchanged)
}

func (n *Node) gfxMatrix() sprec.Mat4 {
	scanner := blob.NewScanner(n.matrixData)
	return scanner.ScanSPMat4()
}

repository: mokiat/lacking

repo_name: mokiat/lacking


text:
// 151
package s15

import (
	"strings"
)

func reverseWords(s string) string {
	fields := strings.Fields(s)
	if len(fields) < 1 {
		return ""
	}

	for i, j := 0, len(fields)-1; i < j; i, j = i+1, j-1 {
		fields[i], fields[j] = fields[j], fields[i]
	}
	return strings.Join(fields, " ")
}

license: MIT

repository: jdxj/leetcode

license_type: permissive

repo_name: jdxj/leetcode

branch_name: refs/heads/master

extension: go


text:
package backend

import (
	"crypto/tls"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"net"
	"net/http"
	"net/url"
	"strings"
	"time"

	"github.com/chengshiwen/influx-tool/util"
	gzip "github.com/klauspost/pgzip"
)

type Backend struct {
	Url       string // nolint:golint
	Username  string
	Password  string
	transport *http.Transport
}

func NewBackend(host string, port int, username string, password string, tlsSkip bool) *Backend {
	url := fmt.Sprintf("http://%s:%d", host, port)
	if tlsSkip {
		url = fmt.Sprintf("https://%s:%d", host, port)
	}
	return &Backend{
		Url:       url,
		Username:  username,
		Password:  password,
		transport: NewTransport(tlsSkip),
	}
}

func NewTransport(tlsSkip bool) *http.Transport {
	return &http.Transport{
		DialContext: (&net.Dialer{
			Timeout:   time.Second * 30,
			KeepAlive: time.Second * 30,
		}).DialContext,
		MaxIdleConns:          100,
		MaxIdleConnsPerHost:   100,
		IdleConnTimeout:       time.Second * 90,
		TLSHandshakeTimeout:   time.Second * 10,
		ExpectContinueTimeout: time.Second * 1,
		TLSClientConfig:       &tls.Config{InsecureSkipVerify: tlsSkip},
	}
}

func NewQueryRequest(method, db, q, epoch string) *http.Request {
	header := http.Header{}
	header.Set("Accept-Encoding", "gzip")
	form := url.Values{}
	form.Set("q", q)
	if db != "" {
		form.Set("db", db)
	}
	if epoch != "" {
		form.Set("epoch", epoch)
	}
	return &http.Request{Method: method, Form: form, Header: header}
}

func (be *Backend) Query(req *http.Request) (body []byte, err error) {
	if len(req.Form) == 0 {
		req.Form = url.Values{}
	}
	req.Form.Del("u")
	req.Form.Del("p")
	req.ContentLength = 0
	if be.Username != "" || be.Password != "" {
		req.SetBasicAuth(be.Username, be.Password)
	}

	req.URL, err = url.Parse(be.Url + "/query?" + req.Form.Encode())
	if err != nil {
		log.Print("internal url parse error: ", err)
		return
	}

	q := strings.TrimSpace(req.FormValue("q"))
	resp, err := be.transport.RoundTrip(req)
	if err != nil {
		log.Printf("query error: %s, the query is %s", err, q)
		return
	}
	defer resp.Body.Close()

	respBody := resp.Body
	if resp.Header.Get("Content-Encoding") == "gzip" {
		b, err := gzip.NewReader(resp.Body)
		if err != nil {
			log.Printf("unable to decode gzip body")
			return nil, err
		}
		defer b.Close()
		respBody = b
	}

	body, err = ioutil.ReadAll(respBody)
	if err != nil {
		log.Printf("read body error: %s, the query is %s", err, q)
		return
	}
	if resp.StatusCode >= 400 {
		rsp, _ := ResponseFromResponseBytes(body)
		err = errors.New(rsp.Err)
	}
	return
}

func (be *Backend) QueryIQL(method, db, q, epoch string) ([]byte, error) {
	return be.Query(NewQueryRequest(method, db, q, epoch))
}

func (be *Backend) GetSeriesValues(db, q string) []string {
	var values []string
	p, err := be.Query(NewQueryRequest("GET", db, q, ""))
	if err != nil {
		return values
	}
	series, _ := SeriesFromResponseBytes(p)
	for _, s := range series {
		for _, v := range s.Values {
			if s.Name == "databases" && v[0].(string) == "_internal" {
				continue
			}
			values = append(values, v[0].(string))
		}
	}
	return values
}

func (be *Backend) GetMeasurements(db string) []string {
	return be.GetSeriesValues(db, "show measurements")
}

func (be *Backend) GetTagKeys(db, meas string) []string {
	return be.GetSeriesValues(db, fmt.Sprintf("show tag keys from \"%s\"", util.EscapeIdentifier(meas)))
}

func (be *Backend) GetFieldKeys(db, meas string) map[string][]string {
	fieldKeys := make(map[string][]string)
	q := fmt.Sprintf("show field keys from \"%s\"", util.EscapeIdentifier(meas))
	p, err := be.Query(NewQueryRequest("GET", db, q, ""))
	if err != nil {
		return fieldKeys
	}
	series, _ := SeriesFromResponseBytes(p)
	for _, s := range series {
		for _, v := range s.Values {
			fk := v[0].(string)
			fieldKeys[fk] = append(fieldKeys[fk], v[1].(string))
		}
	}
	return fieldKeys
}


text:
@inproceedings{Sahoo2019,
 abstract = {An important aspect of health monitoring is effective logging of food consumption. This can help management of diet-related diseases like obesity, diabetes, and even cardiovascular diseases. Moreover, food logging can help fitness enthusiasts, and people who wanting to achieve a target weight. However, food-logging is cumbersome, and requires not only taking additional effort to note down the food item consumed regularly, but also sufficient knowledge of the food item consumed (which is difficult due to the availability of a wide variety of cuisines). With increasing reliance on smart devices, we exploit the convenience offered through the use of smart phones and propose a smart-food logging system: FoodAI, which offers state-of-the-art deep-learning based image recognition capabilities. FoodAI has been developed in Singapore and is particularly focused on food items commonly consumed in Singapore. FoodAI models were trained on a corpus of 400,000 food images from 756 different classes. In this paper we present extensive analysis and insights into the development of this system. FoodAI has been deployed as an API service and is one of the components powering Healthy 365, a mobile app developed by Singapore's Heath Promotion Board. We have over 100 registered organizations (universities, companies, start-ups) subscribing to this service and actively receive several API requests a day. FoodAI has made food logging convenient, aiding smart consumption and a healthy lifestyle.},
 address = {New York, New York, USA},
 author = {Sahoo, Doyen and Hao, Wang and Ke, Shu and Xiongwei, Wu and Le, Hung and Achananuparp, Palakorn and Lim, Ee-Peng and Hoi, Steven C. H.},
 booktitle = {Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining - KDD '19},
 doi = {10.1145/3292500.3330734},
 file = {:home/aek/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Sahoo et al. - 2019 - FoodAI Food Image Recognition via Deep Learning for Smart Food Logging.pdf:pdf},
 isbn = {9781450362016},
 keywords = {Food Computing,Image Recognition,Smart Food Logging},
 pages = {2260--2268},
 publisher = {ACM Press},
 title = {FoodAI: Food Image Recognition via Deep Learning for Smart Food Logging},
 url = {http://dl.acm.org/citation.cfm?doid=3292500.3330734},
 year = {2019}
}

repository: aekpalakorn/academic-kickstart

repo_name: aekpalakorn/academic-kickstart

gha_license_id: MIT

extension: bib


text:
DESCRIPTION = "Big Buck Bunny movie"
LICENSE = "CC-BY"

SRC_URI = "http://mirror.bigbuckbunny.de/peach/bigbuckbunny_movies/big_buck_bunny_720p_surround.avi"

do_install() {
	install -d ${D}${datadir}/movies
	install -m 0644 ${WORKDIR}/big_buck_bunny_720p_surround.avi ${D}${datadir}/movies/
}

FILES_${PN} += "${datadir}/movies"
PACKAGE_ARCH = "all"

SRC_URI[md5sum] = "0da8fe124595f5b206d64cb1400bbefc"
SRC_URI[sha256sum] = "b957d6e6212638441b52d3b620af157cc8d40c2a0342669294854a06edcd528c"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD

extension: bb


text:
#----------------------------------------------------------------
# Generated CMake target import file for configuration "Release".
#----------------------------------------------------------------

# Commands may need to know the format version.
set(CMAKE_IMPORT_FILE_VERSION 1)

# Import target "opencv_cudev" for configuration "Release"
set_property(TARGET opencv_cudev APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudev PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudev300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE ""
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudev300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudev )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudev "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudev300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudev300.dll" )

# Import target "opencv_core" for configuration "Release"
set_property(TARGET opencv_core APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_core PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_core300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_core300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_core )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_core "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_core300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_core300.dll" )

# Import target "opencv_flann" for configuration "Release"
set_property(TARGET opencv_flann APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_flann PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_flann300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_flann300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_flann )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_flann "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_flann300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_flann300.dll" )

# Import target "opencv_imgproc" for configuration "Release"
set_property(TARGET opencv_imgproc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_imgproc PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_imgproc300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_imgproc300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_imgproc )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_imgproc "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_imgproc300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_imgproc300.dll" )

# Import target "opencv_imgcodecs" for configuration "Release"
set_property(TARGET opencv_imgcodecs APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_imgcodecs PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_imgcodecs300.lib"
  IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE ""
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_imgcodecs300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_imgcodecs )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_imgcodecs "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_imgcodecs300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_imgcodecs300.dll" )

# Import target "opencv_videoio" for configuration "Release"
set_property(TARGET opencv_videoio APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_videoio PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_videoio300.lib"
  IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc;opencv_imgcodecs"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE ""
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_videoio300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_videoio )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_videoio "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_videoio300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_videoio300.dll" )

# Import target "opencv_highgui" for configuration "Release"
set_property(TARGET opencv_highgui APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_highgui PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_highgui300.lib"
  IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc;opencv_imgcodecs;opencv_videoio"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE ""
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_highgui300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_highgui )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_highgui "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_highgui300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_highgui300.dll" )

# Import target "opencv_ml" for configuration "Release"
set_property(TARGET opencv_ml APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_ml PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_ml300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_ml300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_ml )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_ml "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_ml300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_ml300.dll" )

# Import target "opencv_features2d" for configuration "Release"
set_property(TARGET opencv_features2d APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_features2d PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_features2d300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_flann;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_features2d300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_features2d )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_features2d "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_features2d300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_features2d300.dll" )

# Import target "opencv_calib3d" for configuration "Release"
set_property(TARGET opencv_calib3d APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_calib3d PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_calib3d300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_flann;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml;opencv_features2d"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_calib3d300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_calib3d )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_calib3d "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_calib3d300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_calib3d300.dll" )

# Import target "opencv_cudaarithm" for configuration "Release"
set_property(TARGET opencv_cudaarithm APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudaarithm PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudaarithm300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudaarithm300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudaarithm )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudaarithm "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudaarithm300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudaarithm300.dll" )

# Import target "opencv_objdetect" for configuration "Release"
set_property(TARGET opencv_objdetect APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_objdetect PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_objdetect300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_objdetect300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_objdetect )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_objdetect "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_objdetect300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_objdetect300.dll" )

# Import target "opencv_cudalegacy" for configuration "Release"
set_property(TARGET opencv_cudalegacy APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudalegacy PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudalegacy300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml;opencv_objdetect"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudalegacy300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudalegacy )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudalegacy "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudalegacy300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudalegacy300.dll" )

# Import target "opencv_cudawarping" for configuration "Release"
set_property(TARGET opencv_cudawarping APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudawarping PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudawarping300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml;opencv_objdetect;opencv_cudalegacy"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudawarping300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudawarping )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudawarping "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudawarping300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudawarping300.dll" )

# Import target "opencv_cuda" for configuration "Release"
set_property(TARGET opencv_cuda APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cuda PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cuda300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_flann;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml;opencv_features2d;opencv_calib3d;opencv_cudaarithm;opencv_objdetect;opencv_cudalegacy;opencv_cudawarping"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cuda300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cuda )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cuda "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cuda300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cuda300.dll" )

# Import target "opencv_cudafilters" for configuration "Release"
set_property(TARGET opencv_cudafilters APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudafilters PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudafilters300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_cudaarithm;opencv_imgproc"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudafilters300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudafilters )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudafilters "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudafilters300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudafilters300.dll" )

# Import target "opencv_cudaimgproc" for configuration "Release"
set_property(TARGET opencv_cudaimgproc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudaimgproc PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudaimgproc300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_cudaarithm;opencv_imgproc;opencv_cudafilters"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudaimgproc300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudaimgproc )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudaimgproc "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudaimgproc300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudaimgproc300.dll" )

# Import target "opencv_video" for configuration "Release"
set_property(TARGET opencv_video APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_video PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_video300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_video300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_video )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_video "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_video300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_video300.dll" )

# Import target "opencv_cudabgsegm" for configuration "Release"
set_property(TARGET opencv_cudabgsegm APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudabgsegm PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudabgsegm300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_cudaarithm;opencv_imgproc;opencv_cudafilters;opencv_cudaimgproc;opencv_video"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudabgsegm300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudabgsegm )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudabgsegm "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudabgsegm300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudabgsegm300.dll" )

# Import target "opencv_cudacodec" for configuration "Release"
set_property(TARGET opencv_cudacodec APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudacodec PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudacodec300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc;opencv_imgcodecs;opencv_videoio"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudacodec300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudacodec )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudacodec "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudacodec300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudacodec300.dll" )

# Import target "opencv_cudafeatures2d" for configuration "Release"
set_property(TARGET opencv_cudafeatures2d APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudafeatures2d PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudafeatures2d300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_cudaarithm;opencv_imgproc;opencv_cudafilters;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml;opencv_objdetect;opencv_cudalegacy;opencv_cudawarping;opencv_flann;opencv_features2d"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudafeatures2d300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudafeatures2d )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudafeatures2d "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudafeatures2d300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudafeatures2d300.dll" )

# Import target "opencv_cudaoptflow" for configuration "Release"
set_property(TARGET opencv_cudaoptflow APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudaoptflow PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudaoptflow300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_cudaarithm;opencv_imgproc;opencv_cudafilters;opencv_cudaimgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml;opencv_objdetect;opencv_cudalegacy;opencv_cudawarping;opencv_video"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudaoptflow300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudaoptflow )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudaoptflow "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudaoptflow300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudaoptflow300.dll" )

# Import target "opencv_cudastereo" for configuration "Release"
set_property(TARGET opencv_cudastereo APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_cudastereo PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudastereo300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_flann;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml;opencv_features2d;opencv_calib3d"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudastereo300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_cudastereo )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_cudastereo "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_cudastereo300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_cudastereo300.dll" )

# Import target "opencv_photo" for configuration "Release"
set_property(TARGET opencv_photo APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_photo PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_photo300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_cudaarithm;opencv_imgproc;opencv_cudafilters;opencv_cudaimgproc"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_photo300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_photo )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_photo "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_photo300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_photo300.dll" )

# Import target "opencv_shape" for configuration "Release"
set_property(TARGET opencv_shape APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_shape PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_shape300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc;opencv_video"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_shape300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_shape )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_shape "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_shape300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_shape300.dll" )

# Import target "opencv_stitching" for configuration "Release"
set_property(TARGET opencv_stitching APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_stitching PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_stitching300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_flann;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml;opencv_features2d;opencv_calib3d;opencv_cudaarithm;opencv_objdetect;opencv_cudalegacy;opencv_cudawarping;opencv_cuda;opencv_cudafilters;opencv_cudafeatures2d"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_stitching300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_stitching )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_stitching "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_stitching300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_stitching300.dll" )

# Import target "opencv_superres" for configuration "Release"
set_property(TARGET opencv_superres APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_superres PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_superres300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_cudaarithm;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_cudacodec;opencv_cudafilters;opencv_cudaimgproc;opencv_highgui;opencv_ml;opencv_objdetect;opencv_cudalegacy;opencv_cudawarping;opencv_video;opencv_cudaoptflow"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_superres300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_superres )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_superres "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_superres300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_superres300.dll" )

# Import target "opencv_ts" for configuration "Release"
set_property(TARGET opencv_ts APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_ts PROPERTIES
  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;cudart;nppc;nppi;npps;cudart;nppc;nppi;npps"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_ts300.lib"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_ts )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_ts "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_ts300.lib" )

# Import target "opencv_videostab" for configuration "Release"
set_property(TARGET opencv_videostab APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(opencv_videostab PROPERTIES
  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_videostab300.lib"
  IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE "opencv_cudev;opencv_core;opencv_flann;opencv_imgproc;opencv_imgcodecs;opencv_videoio;opencv_highgui;opencv_ml;opencv_features2d;opencv_calib3d;opencv_cudaarithm;opencv_objdetect;opencv_cudalegacy;opencv_cudawarping;opencv_cuda;opencv_cudafilters;opencv_cudaimgproc;opencv_video;opencv_cudaoptflow;opencv_photo"
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_videostab300.dll"
  )

list(APPEND _IMPORT_CHECK_TARGETS opencv_videostab )
list(APPEND _IMPORT_CHECK_FILES_FOR_opencv_videostab "${_IMPORT_PREFIX}/x64/vc12/lib/opencv_videostab300.lib" "${_IMPORT_PREFIX}/x64/vc12/bin/opencv_videostab300.dll" )

# Commands beyond this point should not need to know the version.
set(CMAKE_IMPORT_FILE_VERSION)

extension: cmake


text:
@article {Bokulich306167,
	author = {Bokulich, Nicholas and Dillon, Matthew and Bolyen, Evan and Kaehler, Benjamin D and Huttley, Gavin A and Caporaso, J Gregory},
	title = {q2-sample-classifier: machine-learning tools for microbiome classification and regression},
	year = {2018},
	doi = {10.1101/306167},
	journal = {bioRxiv}
}

@article{subramanian2014persistent,
  title={Persistent gut microbiota immaturity in malnourished Bangladeshi children},
  author={Subramanian, Sathish and Huq, Sayeeda and Yatsunenko, Tanya and Haque, Rashidul and Mahfuz, Mustafa and Alam, Mohammed A and Benezra, Amber and DeStefano, Joseph and Meier, Martin F and Muegge, Brian D and Barratt, Michael J and VanArendonk, Laura G and Zhang, Qunyuan and Province, Michael A and Petri, William A and Ahmed, Tahmeed and Gordon, Jeffrey I},
  journal={Nature},
  volume={510},
  number={7505},
  pages={417},
  year={2014},
  publisher={Nature Publishing Group},
  doi={10.1038/nature13421}
}

gha_language: Python


text:
@article{salter2010personal,
 author = {Salter, Anastasia},
 title = {Personal adventures: the shift from player to author},
 year = {2010}
}

repository: AMSUCF/academic-kickstart

repo_name: AMSUCF/academic-kickstart


text:
require acpid.inc

SRC_URI_append = " file://event.c.diff;patch=1 \
                   file://netlink.diff;patch=1 \
                   file://gcc44.diff;patch=1 \
                 "

repository: demsey/openembedded

repo_name: demsey/openembedded


text:
// Copyright 2015 The rkt 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 main

import (
	"encoding/json"
	"flag"

	"github.com/coreos/rkt/store"
)

var (
	cmdImageCatManifest = &Command{
		Name:    "cat-manifest",
		Summary: "Inspect and print the image manifest",
		Usage:   "IMAGE",
		Description: `IMAGE should be a string referencing an image; either a hash, local file on disk, or URL.
They will be checked in that order and the first match will be used.`,
		Run:   runImageCatManifest,
		Flags: &imageCatManifestFlag,
	}
	imageCatManifestFlag flag.FlagSet
	flagPrettyPrint      bool
)

func init() {
	subCommands["image"] = append(subCommands["image"], cmdImageCatManifest)

	imageCatManifestFlag.BoolVar(&flagPrettyPrint, "pretty-print", false, "apply indent to format the output")
}

func runImageCatManifest(args []string) (exit int) {
	if len(args) != 1 {
		printSubCommandUsageByName("image", "cat-manifest", subCommands["image"])
		return 1
	}

	s, err := store.NewStore(globalFlags.Dir)
	if err != nil {
		stderr("image cat-manifest: cannot open store: %v\n", err)
		return 1
	}
	ks := getKeystore()

	fn := &finder{
		imageActionData: imageActionData{
			s:                  s,
			ks:                 ks,
			insecureSkipVerify: true,
			debug:              globalFlags.Debug,
		},
		local:    true,
		withDeps: false,
	}

	h, err := fn.findImage(args[0], "", true)
	if err != nil {
		stderr("image cat-manifest: cannot find image: %v\n", err)
		return 1
	}

	manifest, err := fn.s.GetImageManifest(h.String())
	if err != nil {
		stderr("image cat-manifest: cannot get image manifest: %v\n", err)
		return 1
	}

	var b []byte
	if flagPrettyPrint {
		b, err = json.MarshalIndent(manifest, "", "\t")
	} else {
		b, err = json.Marshal(manifest)
	}
	if err != nil {
		stderr("image cat-manifest: cannot read the image manifest: %v\n", err)
		return 1
	}

	stdout(string(b))
	return 0
}

repository: xnox/rkt

repo_name: xnox/rkt


text:
DESCRIPTION="GNU CGI Library in C"
SECTION="libs"
Maintainer = "Jiff Shen <jiff.shen@avocent.com>"
Homepage= "http://catchen.org/gcgi/"
LICENCE = "LGPL"

SRC_URI = "http://catchen.org/gcgi/${P}.tar.gz"

S = ${WORKDIR}/libgcgi.a-${PV}

EXTRA_OECONF = "--with-openssl"

inherit autotools


text:
@inproceedings{goodwin2011cohort,
 abstract = {This paper describes the system created by the University of Texas at Dallas for contentbased medical record retrieval submitted to the TREC 2011 Medical Records Track. Our system builds a query by extracting keywords from a given topic using a Wikipedia-based approach. We use regular expressions to extract age, gender, and negation requirements. Each query is then expanded by relying on UMLS, SNOMED, Wikipedia, and PubMed co-occurrence data for retrieval. Four runs were submitted: two based on Lucene with varying scoring methods, and two based on a hybrid approach with varying negation detection techniques. Our highest scoring submission achieved a MAP score of 40.8.},
 address = {Gaithersburg, MD, USA},
 author = {Goodwin, Travis and Rink, Bryan and Roberts, Kirk and Harabagiu, Sanda M},
 booktitle = {Proceedings of the Twentieth Text REtrieval Conference (TREC 2011)},
 month = {November},
 pages = {1--11},
 publisher = {National Institute of Standards and Technology},
 title = {Cohort Shepherd: Discovering Cohort Traits from Hospital Visits},
 url = {https://trec.nist.gov/pubs/trec20/papers/UTD_HLT.medical.update.pdf},
 year = {2011}
}


text:
// Copyright 2021 ZUP IT SERVICOS EM TECNOLOGIA E INOVACAO SA
//
// 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 database

import (
	"encoding/json"

	"github.com/stretchr/testify/mock"

	"github.com/ZupIT/horusec-devkit/pkg/services/database/response"
	mockUtils "github.com/ZupIT/horusec-devkit/pkg/utils/mock"
)

type Mock struct {
	mock.Mock
}

func (m *Mock) IsAvailable() bool {
	args := m.MethodCalled("IsAvailable")
	return mockUtils.ReturnBool(args, 0)
}

func (m *Mock) Find(entityPointer interface{}, _ map[string]interface{}, _ string) response.IResponse {
	args := m.MethodCalled("Find")
	return m.reflectValues(entityPointer, args.Get(0).(response.IResponse))
}

func (m *Mock) First(entityPointer interface{}, _ map[string]interface{}, _ string) response.IResponse {
	args := m.MethodCalled("First")
	return m.reflectValues(entityPointer, args.Get(0).(response.IResponse))
}

func (m *Mock) Raw(_ string, entityPointer interface{}, _ ...interface{}) response.IResponse {
	args := m.MethodCalled("Raw")
	return m.reflectValues(entityPointer, args.Get(0).(response.IResponse))
}

func (m *Mock) StartTransaction() IDatabaseWrite {
	args := m.MethodCalled("StartTransaction")
	return args.Get(0).(IDatabaseWrite)
}

func (m *Mock) RollbackTransaction() response.IResponse {
	args := m.MethodCalled("RollbackTransaction")
	return args.Get(0).(response.IResponse)
}

func (m *Mock) CommitTransaction() response.IResponse {
	args := m.MethodCalled("CommitTransaction")
	return args.Get(0).(response.IResponse)
}

func (m *Mock) Create(_ interface{}, _ string) response.IResponse {
	args := m.MethodCalled("Create")
	return args.Get(0).(response.IResponse)
}

func (m *Mock) CreateOrUpdate(_ interface{}, _ map[string]interface{}, _ string) response.IResponse {
	args := m.MethodCalled("CreateOrUpdate")
	return args.Get(0).(response.IResponse)
}

func (m *Mock) Update(_ interface{}, _ map[string]interface{}, _ string) response.IResponse {
	args := m.MethodCalled("Update")
	return args.Get(0).(response.IResponse)
}

func (m *Mock) Delete(_ map[string]interface{}, _ string) response.IResponse {
	args := m.MethodCalled("Delete")
	return args.Get(0).(response.IResponse)
}

func (m *Mock) FindPreload(entityPointer interface{}, _ map[string]interface{}, _ map[string][]interface{}, _ string) response.IResponse {
	args := m.MethodCalled("FindPreload")
	return m.reflectValues(entityPointer, args.Get(0).(response.IResponse))
}

func (m *Mock) FindPreloadWitLimitAndPage(entityPointer interface{}, _ map[string]interface{},
	_ map[string][]interface{}, _ string, _, _ int) response.IResponse {
	args := m.MethodCalled("FindPreloadWitLimitAndPage")
	return m.reflectValues(entityPointer, args.Get(0).(response.IResponse))
}

func (m *Mock) reflectValues(entityPointer interface{}, resp response.IResponse) response.IResponse {
	bytes, _ := json.Marshal(resp.GetData())
	_ = json.Unmarshal(bytes, entityPointer)
	return resp
}

branch_name: refs/heads/main

gha_license_id: NOASSERTION


text:
package cmd

import (
	"os"
	"path/filepath"

	"github.com/exercism/configlet/ui"
)

func ExampleTree() {
	treeTrack(filepath.FromSlash("../fixtures/tree/config.json"))
	// Output:
	// Numbers
	// =======
	//
	// core
	// ----
	// ├─ one
	// │  └─ five
	// │
	// ├─ two
	// │  ├─ six
	// │  │  ├─ ten
	// │  │  └─ twelve
	// │  └─ thirteen
	// │
	// ├─ nine
	// │
	// └─ eleven
	//
	// bonus
	// -----
	// seven
	// eight
}

func ExampleTreeDifficulty() {

	orig := withDifficulty
	withDifficulty = true
	defer func() { withDifficulty = orig }()

	treeTrack(filepath.FromSlash("../fixtures/tree/config.json"))
	// Output:
	// Numbers
	// =======
	//
	// core
	// ----
	// ├─ one [1]
	// │  └─ five [2]
	// │
	// ├─ two [1]
	// │  ├─ six [3]
	// │  │  ├─ ten [6]
	// │  │  └─ twelve [8]
	// │  └─ thirteen [5]
	// │
	// ├─ nine [4]
	// │
	// └─ eleven [4]
	//
	// bonus
	// -----
	// seven [3]
	// eight [5]
}

func ExampleTreeWarnings() {
	orig := ui.ErrOut
	ui.ErrOut = os.Stdout

	defer func() { ui.ErrOut = orig }()

	treeTrack(filepath.FromSlash("../fixtures/tree/config-outdated.json"))
	// Output:
	// Numbers
	// =======
	// -> Cannot find any unlockable exercises, this track may be missing a nextercism compatible configuration.
	// -> Cannot find any core exercises, this track may be missing a nextercism compatible configuration.
	//
	// bonus
	// -----
	// one
	// two
}

func ExampleInvalidUnlockedBy() {
	orig := ui.ErrOut
	ui.ErrOut = os.Stdout

	defer func() { ui.ErrOut = orig }()

	treeTrack(filepath.FromSlash("../fixtures/tree/config-invalid-unlocked-by.json"))
	// Output:
	// Numbers
	// =======
	// -> Exercise "six" has an invalid unlocked_by slug: "a non-existing exercise", this track may be missing a nextercism compatible configuration.
	//
	// core
	// ----
	// ├─ one
	// │  └─ five
	// │
	// └─ two
	//
	// bonus
	// -----
	// seven
}


text:
@article{rothman_no_1990,
	title = {No adjustments are needed for multiple comparisons},
	volume = {1},
	issn = {1044-3983},
	url = {http://www.ncbi.nlm.nih.gov/pubmed/2081237},
	abstract = {Abstract: "Adjustments for making multiple comparisons in large bodies of data are recommended to avoid rejecting the null hypothesis too readily. Unfortunately, reducing the type I error for null associations increases the type {II} error for those associations that are not null. The theoretical basis for advocating a routine adjustment for multiple comparisons is the "universal null hypothesis" that "chance" serves as the first-order explanation for observed phenomena. This hypothesis undermines the basic premises of empirical research, which holds that nature follows regular laws that may be studied through observations. A policy of not making adjustments for multiple comparisons is preferable because it will lead to fewer errors of interpretation when the data under evaluation are not random numbers but actual observations on nature. Furthermore, scientists should not be so reluctant to explore leads that may turn out to be wrong that they penalize themselves by missing possibly important findings."},
	pages = {43--46},
	number = {1},
	journaltitle = {Epidemiology (Cambridge, Mass.)},
	shortjournal = {Epidemiology},
	author = {Rothman, K J},
	urldate = {2011-02-23},
	date = {1990-01},
	pmid = {2081237},
	tags = {Bias (Epidemiology), Data Interpretation, Statistical, Humans, Multivariate Analysis, Probability}
}

repository: pmean/build-website

repo_name: pmean/build-website


text:
/*
Copyright 2021 The KubeEdge 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 dao

import (
	"database/sql"
	"errors"
	"testing"

	"github.com/astaxie/beego/orm"
	"github.com/golang/mock/gomock"

	"github.com/kubeedge/kubeedge/edge/mocks/beego"
	"github.com/kubeedge/kubeedge/edge/pkg/common/dbm"
)

const (
	// FailedDBOperation is common Database operation fail message
	FailedDBOperation = "Failed DB Operation"
)

var errFailedDBOperation = errors.New(FailedDBOperation)

var testURL = TargetUrls{
	URL: "http://127.0.0.1/test",
}

// TestInsertUrls is function to test InsertTopics
func TestInsertUrls(t *testing.T) {
	// Initialize Global Variables (Mocks)
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	ormerMock := beego.NewMockOrmer(mockCtrl)
	rawSeterMock := beego.NewMockRawSeter(mockCtrl)
	dbm.DBAccess = ormerMock

	cases := []struct {
		// name is name of the testcase
		name string
		// returnSQL is first return of mock interface rawSeterMock's Exec function
		returnSQL sql.Result
		// returnErr is second return of mock interface rawSeterMock's Exec function which is also expected error
		returnErr error
		// returnRaw is the return of mock interface ormerMock's Raw function
		returnRaw orm.RawSeter
	}{{
		// Success Case
		name:      "SuccessCase",
		returnSQL: nil,
		returnErr: nil,
		returnRaw: rawSeterMock,
	}, {
		// Failure Case
		name:      "FailureCase",
		returnSQL: nil,
		returnErr: errFailedDBOperation,
		returnRaw: rawSeterMock,
	},
	}

	// run the test cases
	for _, test := range cases {
		t.Run(test.name, func(t *testing.T) {
			rawSeterMock.EXPECT().Exec().Return(test.returnSQL, test.returnErr).Times(1)
			ormerMock.EXPECT().Raw(gomock.Any(), gomock.Any()).Return(test.returnRaw).Times(1)
			err := InsertUrls(testURL.URL)
			if test.returnErr != err {
				t.Errorf("Insert or Update Meta Case failed : wanted %v and got %v", test.returnErr, err)
			}
		})
	}
}

// TestDeleteTopicsByKey is function to test DeleteTopicsByKey
func TestDeleteTopicsByKey(t *testing.T) {
	// Initialize Global Variables (Mocks)
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	ormerMock := beego.NewMockOrmer(mockCtrl)
	querySeterMock := beego.NewMockQuerySeter(mockCtrl)
	dbm.DBAccess = ormerMock

	cases := []struct {
		// name is name of the testcase
		name string
		// filterReturn is the return of mock interface querySeterMock's filter function
		filterReturn orm.QuerySeter
		// deleteReturnInt is the first return of mock interface querySeterMock's delete function
		deleteReturnInt int64
		// deleteReturnErr is the second return of mock interface querySeterMocks's delete function also expected error
		deleteReturnErr error
		// queryTableReturn is the return of mock interface ormerMock's QueryTable function
		queryTableReturn orm.QuerySeter
	}{{
		// Failure Case
		name:             "FailureCase",
		filterReturn:     querySeterMock,
		deleteReturnInt:  int64(0),
		deleteReturnErr:  errFailedDBOperation,
		queryTableReturn: querySeterMock,
	},
		{
			// Success Case
			name:             "SuccessCase",
			filterReturn:     querySeterMock,
			deleteReturnInt:  int64(1),
			deleteReturnErr:  nil,
			queryTableReturn: querySeterMock,
		}}

	// run the test cases
	for _, test := range cases {
		t.Run(test.name, func(t *testing.T) {
			querySeterMock.EXPECT().Filter(gomock.Any(), gomock.Any()).Return(test.filterReturn).Times(1)
			querySeterMock.EXPECT().Delete().Return(test.deleteReturnInt, test.deleteReturnErr).Times(1)
			ormerMock.EXPECT().QueryTable(gomock.Any()).Return(test.queryTableReturn).Times(1)
			err := DeleteUrlsByKey("http://127.0.0.1/test")
			if test.deleteReturnErr != err {
				t.Errorf("Delete Meta By Key Case failed : wanted %v and got %v", test.deleteReturnErr, err)
			}
		})
	}
}

func TestIsTableEmpty(t *testing.T) {
	// Initialize Global Variables (Mocks)
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	ormerMock := beego.NewMockOrmer(mockCtrl)
	querySeterMock := beego.NewMockQuerySeter(mockCtrl)
	dbm.DBAccess = ormerMock

	cases := []struct {
		// name is name of the testcase
		name string
		// queryTableReturn is the return of mock interface ormerMock's QueryTable function
		queryTableReturn orm.QuerySeter
		// result of the function
		Result bool
	}{{
		// not empty
		name:             "count > 0",
		queryTableReturn: querySeterMock,
		Result:           false,
	},
		{
			// empty
			name:             "count = 0",
			queryTableReturn: querySeterMock,
			Result:           true,
		}}
	// run the test cases
	for _, test := range cases {
		t.Run(test.name, func(t *testing.T) {
			if test.name == "count > 0" {
				ormerMock.EXPECT().QueryTable(gomock.Any()).Return(test.queryTableReturn).Times(1)
				querySeterMock.EXPECT().Count().Return(int64(1), nil)
				if test.Result != IsTableEmpty() {
					t.Errorf("except false but get true")
				}
			} else {
				ormerMock.EXPECT().QueryTable(gomock.Any()).Return(test.queryTableReturn).Times(1)
				querySeterMock.EXPECT().Count().Return(int64(0), nil)
				if test.Result != IsTableEmpty() {
					t.Errorf("except true but get false")
				}
			}
		})
	}
}

func TestGetUrlsByKey(t *testing.T) {
	// Initialize Global Variables (Mocks)
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	ormerMock := beego.NewMockOrmer(mockCtrl)
	querySeterMock := beego.NewMockQuerySeter(mockCtrl)
	dbm.DBAccess = ormerMock

	cases := []struct {
		// name is name of the testcase
		name string
		// key os the param of the functoion
		key string
		// queryTableReturn is the return of mock interface ormerMock's QueryTable function
		queryTableReturn orm.QuerySeter
		// filterReturn is the return of mock interface querySeterMock's filter function
		filterReturn orm.QuerySeter
		// returnErr is second return of mock interface rawSeterMock's Exec function which is also expected error
		returnErr error
	}{{
		name:             "SuccessCase",
		key:              "test",
		queryTableReturn: querySeterMock,
		filterReturn:     querySeterMock,
		returnErr:        nil,
	},
		{
			name:             "FailureCase",
			key:              "test",
			queryTableReturn: querySeterMock,
			filterReturn:     querySeterMock,
			returnErr:        errFailedDBOperation,
		}}
	// run the test cases
	for _, test := range cases {
		t.Run(test.name, func(t *testing.T) {
			ormerMock.EXPECT().QueryTable(gomock.Any()).Return(test.queryTableReturn).Times(1)
			querySeterMock.EXPECT().Filter(gomock.Any(), gomock.Any()).Return(test.filterReturn).Times(1)
			querySeterMock.EXPECT().One(gomock.Any()).Return(test.returnErr).Times(1)
			if _, err := GetUrlsByKey(test.key); test.returnErr != err {
				t.Errorf("get url By key case failed : wanted %v and got %v", test.returnErr, err)
			}
		})
	}
}

repository: kubeedge/kubeedge

repo_name: kubeedge/kubeedge

gha_language: Go


text:
SUMMARY = "Pure python implementation of DES and TRIPLE DES encryption algorithm"
HOMEPAGE = "http://twhiteman.netfirms.com/des.html/"
SECTION = "devel/python"
LICENSE = "Public Domain"
LIC_FILES_CHKSUM = "file://README.txt;md5=96b9ebbcf1d9bc43eb36e259e83fbbe8"

RDEPENDS_${PN} += "python-core"

SRC_URI = "http://twhiteman.netfirms.com/pyDES/pyDes-${PV}.zip"
SRC_URI[md5sum] = "90f06a24a1ee73fb0e235571d51c287a"
SRC_URI[sha256sum] = "9cc6e509f627ef1c2d318730d22f1a33f23b41e1ec223b55a6420f2861266d76"

S = "${WORKDIR}/pyDes-${PV}"

inherit setuptools

repository: johnnykv/meta-crow

repo_name: johnnykv/meta-crow


text:
package cloudformation

import (
	"encoding/json"
)

// AWSBatchJobDefinition_MountPoints AWS CloudFormation Resource (AWS::Batch::JobDefinition.MountPoints)
// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-mountpoints.html
type AWSBatchJobDefinition_MountPoints struct {

	// ContainerPath AWS CloudFormation Property
	// Required: false
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-mountpoints.html#cfn-batch-jobdefinition-mountpoints-containerpath
	ContainerPath *Value `json:"ContainerPath,omitempty"`

	// ReadOnly AWS CloudFormation Property
	// Required: false
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-mountpoints.html#cfn-batch-jobdefinition-mountpoints-readonly
	ReadOnly *Value `json:"ReadOnly,omitempty"`

	// SourceVolume AWS CloudFormation Property
	// Required: false
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-mountpoints.html#cfn-batch-jobdefinition-mountpoints-sourcevolume
	SourceVolume *Value `json:"SourceVolume,omitempty"`
}

// AWSCloudFormationType returns the AWS CloudFormation resource type
func (r *AWSBatchJobDefinition_MountPoints) AWSCloudFormationType() string {
	return "AWS::Batch::JobDefinition.MountPoints"
}

func (r *AWSBatchJobDefinition_MountPoints) MarshalJSON() ([]byte, error) {
	return json.Marshal(*r)
}

repository: errordeveloper/goformation

repo_name: errordeveloper/goformation


text:
package sets

import (
	"github.com/feyeleanor/slices"
)

type umap	map[uint] bool

func (m umap) Len() int {
	return len(m)
}

func (m umap) Member(i interface{}) (r bool) {
	if i, ok := i.(uint); ok {
		r = m[i]
	}
	return
}

func (m umap) Include(v interface{}) {
	switch v := v.(type) {
	case []uint:
		for i := len(v) - 1; i > -1; i-- {
			m[v[i]] = true
		}
	case uint:
		m[v] = true
	default:
		panic(v)
	}
}

func (m umap) Each(f interface{}) {
	switch f := f.(type) {
	case func(uint):
		for k, v := range m {
			if v {
				f(k)
			}
		}
	case func(interface{}):
		for k, v := range m {
			if v {
				f(k)
			}
		}
	}
}

type uset struct {
	umap
}

func USet(v... uint) (r uset) {
	r.umap = make(umap)
	r.Include(v)
	return
}

func (s uset) Empty() Set {
	return USet()
}

func (s uset) String() (t string) {
	elements := slices.USlice{}
	s.Each(func(v uint) {
		elements = append(elements, v)
	})
	slices.Sort(elements)
	return elements.String()
}

func (s uset) Intersection(o Set) Set {
	r := USet()
	s.Each(func(v uint) {
		if o.Member(v) {
			r.Include(v)
		}
	})
	return r
}

func (s uset) Union(o Set) Set {
	r := USet()
	s.Each(func(v uint) {
		r.Include(v)
	})
	o.Each(func(v uint) {
		r.Include(v)
	})
	return r
}

func (s uset) Difference(o Set) Set {
	r := USet()
	s.Each(func(v uint) {
		if !o.Member(v) {
			r.Include(v)
		}
	})
	return r
}

func (s uset) Equal(o interface{}) (r bool) {
	if o, ok := o.(Set); ok {
		if r = s.Len() == o.Len(); r {
			s.Each(func(v uint) {
				if !o.Member(v) {
					r = false
				}
			})
		}
	}
	return
}

func (s uset) Sum() interface{} {
	var r uint
	s.Each(func(v uint) {
		r += v
	})
	return r
}

func (s uset) Product() interface{} {
	r := uint(1)
	s.Each(func(v uint) {
		r *= v
	})
	return r
}

repository: f/koding

repo_name: f/koding

gha_language: CoffeeScript


text:
/*
Copyright 2019 Cisco Systems

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.
*/

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

package cisco_ios_xr_fib_common_oper_fib_nodes_node_protocols_protocol_vrfs_vrf_nh_info_detail_hardware_egress_nh_info_special_detail_hardware_egress_nh_info_special_punt_detail_hardware_egress

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

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

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

type FibShNhinfo_KEYS struct {
	NodeName             string   `protobuf:"bytes,1,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	ProtocolName         string   `protobuf:"bytes,2,opt,name=protocol_name,json=protocolName,proto3" json:"protocol_name,omitempty"`
	VrfName              string   `protobuf:"bytes,3,opt,name=vrf_name,json=vrfName,proto3" json:"vrf_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_FibShNhinfo_KEYS proto.InternalMessageInfo

func (m *FibShNhinfo_KEYS) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *FibShNhinfo_KEYS) GetProtocolName() string {
	if m != nil {
		return m.ProtocolName
	}
	return ""
}

func (m *FibShNhinfo_KEYS) GetVrfName() string {
	if m != nil {
		return m.VrfName
	}
	return ""
}

type FibShNhinfoPwheExt struct {
	PwheAdjacencyClientData uint32   `protobuf:"varint,1,opt,name=pwhe_adjacency_client_data,json=pwheAdjacencyClientData,proto3" json:"pwhe_adjacency_client_data,omitempty"`
	Vctype                  uint32   `protobuf:"varint,2,opt,name=vctype,proto3" json:"vctype,omitempty"`
	VcInternalLabel         uint32   `protobuf:"varint,3,opt,name=vc_internal_label,json=vcInternalLabel,proto3" json:"vc_internal_label,omitempty"`
	CwEnabled               bool     `protobuf:"varint,4,opt,name=cw_enabled,json=cwEnabled,proto3" json:"cw_enabled,omitempty"`
	L2OverheadBytes         uint32   `protobuf:"varint,5,opt,name=l2_overhead_bytes,json=l2OverheadBytes,proto3" json:"l2_overhead_bytes,omitempty"`
	Dot1QVlanTag            uint32   `protobuf:"varint,6,opt,name=dot1q_vlan_tag,json=dot1qVlanTag,proto3" json:"dot1q_vlan_tag,omitempty"`
	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
	XXX_unrecognized        []byte   `json:"-"`
	XXX_sizecache           int32    `json:"-"`
}

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

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

var xxx_messageInfo_FibShNhinfoPwheExt proto.InternalMessageInfo

func (m *FibShNhinfoPwheExt) GetPwheAdjacencyClientData() uint32 {
	if m != nil {
		return m.PwheAdjacencyClientData
	}
	return 0
}

func (m *FibShNhinfoPwheExt) GetVctype() uint32 {
	if m != nil {
		return m.Vctype
	}
	return 0
}

func (m *FibShNhinfoPwheExt) GetVcInternalLabel() uint32 {
	if m != nil {
		return m.VcInternalLabel
	}
	return 0
}

func (m *FibShNhinfoPwheExt) GetCwEnabled() bool {
	if m != nil {
		return m.CwEnabled
	}
	return false
}

func (m *FibShNhinfoPwheExt) GetL2OverheadBytes() uint32 {
	if m != nil {
		return m.L2OverheadBytes
	}
	return 0
}

func (m *FibShNhinfoPwheExt) GetDot1QVlanTag() uint32 {
	if m != nil {
		return m.Dot1QVlanTag
	}
	return 0
}

type FibShFibObjBase struct {
	ObjectReferenceCount uint32   `protobuf:"varint,1,opt,name=object_reference_count,json=objectReferenceCount,proto3" json:"object_reference_count,omitempty"`
	ObjectFlags          uint32   `protobuf:"varint,2,opt,name=object_flags,json=objectFlags,proto3" json:"object_flags,omitempty"`
	ObjectType           uint32   `protobuf:"varint,3,opt,name=object_type,json=objectType,proto3" json:"object_type,omitempty"`
	ObjectTimeStamp      uint64   `protobuf:"varint,4,opt,name=object_time_stamp,json=objectTimeStamp,proto3" json:"object_time_stamp,omitempty"`
	ObjectPointer        uint64   `protobuf:"varint,5,opt,name=object_pointer,json=objectPointer,proto3" json:"object_pointer,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_FibShFibObjBase proto.InternalMessageInfo

func (m *FibShFibObjBase) GetObjectReferenceCount() uint32 {
	if m != nil {
		return m.ObjectReferenceCount
	}
	return 0
}

func (m *FibShFibObjBase) GetObjectFlags() uint32 {
	if m != nil {
		return m.ObjectFlags
	}
	return 0
}

func (m *FibShFibObjBase) GetObjectType() uint32 {
	if m != nil {
		return m.ObjectType
	}
	return 0
}

func (m *FibShFibObjBase) GetObjectTimeStamp() uint64 {
	if m != nil {
		return m.ObjectTimeStamp
	}
	return 0
}

func (m *FibShFibObjBase) GetObjectPointer() uint64 {
	if m != nil {
		return m.ObjectPointer
	}
	return 0
}

type FibShExtBase struct {
	ObjectBase           *FibShFibObjBase `protobuf:"bytes,1,opt,name=object_base,json=objectBase,proto3" json:"object_base,omitempty"`
	ParentObjectPointer  uint64           `protobuf:"varint,2,opt,name=parent_object_pointer,json=parentObjectPointer,proto3" json:"parent_object_pointer,omitempty"`
	BackObjectPointer    uint64           `protobuf:"varint,3,opt,name=back_object_pointer,json=backObjectPointer,proto3" json:"back_object_pointer,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_FibShExtBase proto.InternalMessageInfo

func (m *FibShExtBase) GetObjectBase() *FibShFibObjBase {
	if m != nil {
		return m.ObjectBase
	}
	return nil
}

func (m *FibShExtBase) GetParentObjectPointer() uint64 {
	if m != nil {
		return m.ParentObjectPointer
	}
	return 0
}

func (m *FibShExtBase) GetBackObjectPointer() uint64 {
	if m != nil {
		return m.BackObjectPointer
	}
	return 0
}

type FibShNhinfoExtRepDet struct {
	NhInfoReplicatedType      uint32   `protobuf:"varint,1,opt,name=nh_info_replicated_type,json=nhInfoReplicatedType,proto3" json:"nh_info_replicated_type,omitempty"`
	NhInfoReplicatedNhId      uint32   `protobuf:"varint,2,opt,name=nh_info_replicated_nh_id,json=nhInfoReplicatedNhId,proto3" json:"nh_info_replicated_nh_id,omitempty"`
	NhInfoReplicatedEncapId   uint64   `protobuf:"varint,3,opt,name=nh_info_replicated_encap_id,json=nhInfoReplicatedEncapId,proto3" json:"nh_info_replicated_encap_id,omitempty"`
	NhInfoReplicatedInterface string   `protobuf:"bytes,4,opt,name=nh_info_replicated_interface,json=nhInfoReplicatedInterface,proto3" json:"nh_info_replicated_interface,omitempty"`
	XXX_NoUnkeyedLiteral      struct{} `json:"-"`
	XXX_unrecognized          []byte   `json:"-"`
	XXX_sizecache             int32    `json:"-"`
}

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

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

var xxx_messageInfo_FibShNhinfoExtRepDet proto.InternalMessageInfo

func (m *FibShNhinfoExtRepDet) GetNhInfoReplicatedType() uint32 {
	if m != nil {
		return m.NhInfoReplicatedType
	}
	return 0
}

func (m *FibShNhinfoExtRepDet) GetNhInfoReplicatedNhId() uint32 {
	if m != nil {
		return m.NhInfoReplicatedNhId
	}
	return 0
}

func (m *FibShNhinfoExtRepDet) GetNhInfoReplicatedEncapId() uint64 {
	if m != nil {
		return m.NhInfoReplicatedEncapId
	}
	return 0
}

func (m *FibShNhinfoExtRepDet) GetNhInfoReplicatedInterface() string {
	if m != nil {
		return m.NhInfoReplicatedInterface
	}
	return ""
}

type FibShNhinfoExtCmnDet struct {
	Type                 string                `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	SnecdNhr             *FibShNhinfoExtRepDet `protobuf:"bytes,2,opt,name=snecd_nhr,json=snecdNhr,proto3" json:"snecd_nhr,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_FibShNhinfoExtCmnDet proto.InternalMessageInfo

func (m *FibShNhinfoExtCmnDet) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *FibShNhinfoExtCmnDet) GetSnecdNhr() *FibShNhinfoExtRepDet {
	if m != nil {
		return m.SnecdNhr
	}
	return nil
}

type FibShNhinfoExtDet struct {
	NhInfoExtensionBase   *FibShExtBase         `protobuf:"bytes,1,opt,name=nh_info_extension_base,json=nhInfoExtensionBase,proto3" json:"nh_info_extension_base,omitempty"`
	NhInfoExtensionDetail *FibShNhinfoExtCmnDet `protobuf:"bytes,2,opt,name=nh_info_extension_detail,json=nhInfoExtensionDetail,proto3" json:"nh_info_extension_detail,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}              `json:"-"`
	XXX_unrecognized      []byte                `json:"-"`
	XXX_sizecache         int32                 `json:"-"`
}

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

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

var xxx_messageInfo_FibShNhinfoExtDet proto.InternalMessageInfo

func (m *FibShNhinfoExtDet) GetNhInfoExtensionBase() *FibShExtBase {
	if m != nil {
		return m.NhInfoExtensionBase
	}
	return nil
}

func (m *FibShNhinfoExtDet) GetNhInfoExtensionDetail() *FibShNhinfoExtCmnDet {
	if m != nil {
		return m.NhInfoExtensionDetail
	}
	return nil
}

type FibShNhinfoExt struct {
	NhInfoExtensionDetail []*FibShNhinfoExtDet `protobuf:"bytes,1,rep,name=nh_info_extension_detail,json=nhInfoExtensionDetail,proto3" json:"nh_info_extension_detail,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}             `json:"-"`
	XXX_unrecognized      []byte               `json:"-"`
	XXX_sizecache         int32                `json:"-"`
}

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

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

var xxx_messageInfo_FibShNhinfoExt proto.InternalMessageInfo

func (m *FibShNhinfoExt) GetNhInfoExtensionDetail() []*FibShNhinfoExtDet {
	if m != nil {
		return m.NhInfoExtensionDetail
	}
	return nil
}

type FibShNhinfo struct {
	SiLinkProto           uint32              `protobuf:"varint,50,opt,name=si_link_proto,json=siLinkProto,proto3" json:"si_link_proto,omitempty"`
	SiNhinfo              uint32              `protobuf:"varint,51,opt,name=si_nhinfo,json=siNhinfo,proto3" json:"si_nhinfo,omitempty"`
	SiNhtype              uint32              `protobuf:"varint,52,opt,name=si_nhtype,json=siNhtype,proto3" json:"si_nhtype,omitempty"`
	SiIfh                 uint32              `protobuf:"varint,53,opt,name=si_ifh,json=siIfh,proto3" json:"si_ifh,omitempty"`
	SiPfiInterfaceType    uint32              `protobuf:"varint,54,opt,name=si_pfi_interface_type,json=siPfiInterfaceType,proto3" json:"si_pfi_interface_type,omitempty"`
	SiAdjPtr              uint32              `protobuf:"varint,55,opt,name=si_adj_ptr,json=siAdjPtr,proto3" json:"si_adj_ptr,omitempty"`
	SiAdjPresent          bool                `protobuf:"varint,56,opt,name=si_adj_present,json=siAdjPresent,proto3" json:"si_adj_present,omitempty"`
	SiSpecialType         uint32              `protobuf:"varint,57,opt,name=si_special_type,json=siSpecialType,proto3" json:"si_special_type,omitempty"`
	SiRefcount            uint32              `protobuf:"varint,58,opt,name=si_refcount,json=siRefcount,proto3" json:"si_refcount,omitempty"`
	SiFlags               uint32              `protobuf:"varint,59,opt,name=si_flags,json=siFlags,proto3" json:"si_flags,omitempty"`
	SiAdjIf               uint32              `protobuf:"varint,60,opt,name=si_adj_if,json=siAdjIf,proto3" json:"si_adj_if,omitempty"`
	SiExtPfx              []uint32            `protobuf:"varint,61,rep,packed,name=si_ext_pfx,json=siExtPfx,proto3" json:"si_ext_pfx,omitempty"`
	SiExtPfxLen           uint32              `protobuf:"varint,62,opt,name=si_ext_pfx_len,json=siExtPfxLen,proto3" json:"si_ext_pfx_len,omitempty"`
	SiExtPfxProto         uint32              `protobuf:"varint,63,opt,name=si_ext_pfx_proto,json=siExtPfxProto,proto3" json:"si_ext_pfx_proto,omitempty"`
	SiAdjAddress          []uint32            `protobuf:"varint,64,rep,packed,name=si_adj_address,json=siAdjAddress,proto3" json:"si_adj_address,omitempty"`
	SiAdjAddrlen          uint32              `protobuf:"varint,65,opt,name=si_adj_addrlen,json=siAdjAddrlen,proto3" json:"si_adj_addrlen,omitempty"`
	SiAdjAddrProto        uint32              `protobuf:"varint,66,opt,name=si_adj_addr_proto,json=siAdjAddrProto,proto3" json:"si_adj_addr_proto,omitempty"`
	SiAdjRwLen            uint32              `protobuf:"varint,67,opt,name=si_adj_rw_len,json=siAdjRwLen,proto3" json:"si_adj_rw_len,omitempty"`
	SiAdjRw               []uint32            `protobuf:"varint,68,rep,packed,name=si_adj_rw,json=siAdjRw,proto3" json:"si_adj_rw,omitempty"`
	SiDepNhinfoType       uint32              `protobuf:"varint,69,opt,name=si_dep_nhinfo_type,json=siDepNhinfoType,proto3" json:"si_dep_nhinfo_type,omitempty"`
	SiDepNhinfo           uint32              `protobuf:"varint,70,opt,name=si_dep_nhinfo,json=siDepNhinfo,proto3" json:"si_dep_nhinfo,omitempty"`
	SiDepNhinfoIfh        uint32              `protobuf:"varint,71,opt,name=si_dep_nhinfo_ifh,json=siDepNhinfoIfh,proto3" json:"si_dep_nhinfo_ifh,omitempty"`
	SiBkupFrr             uint32              `protobuf:"varint,72,opt,name=si_bkup_frr,json=siBkupFrr,proto3" json:"si_bkup_frr,omitempty"`
	SiProtectFrr          uint32              `protobuf:"varint,73,opt,name=si_protect_frr,json=siProtectFrr,proto3" json:"si_protect_frr,omitempty"`
	SiBkupNhinfo          uint32              `protobuf:"varint,74,opt,name=si_bkup_nhinfo,json=siBkupNhinfo,proto3" json:"si_bkup_nhinfo,omitempty"`
	SiBkupIfh             uint32              `protobuf:"varint,75,opt,name=si_bkup_ifh,json=siBkupIfh,proto3" json:"si_bkup_ifh,omitempty"`
	SiBkupAddr            []uint32            `protobuf:"varint,76,rep,packed,name=si_bkup_addr,json=siBkupAddr,proto3" json:"si_bkup_addr,omitempty"`
	SiBkupAddrlen         uint32              `protobuf:"varint,77,opt,name=si_bkup_addrlen,json=siBkupAddrlen,proto3" json:"si_bkup_addrlen,omitempty"`
	SiBkupAddrProto       uint32              `protobuf:"varint,78,opt,name=si_bkup_addr_proto,json=siBkupAddrProto,proto3" json:"si_bkup_addr_proto,omitempty"`
	SiFrrActive           bool                `protobuf:"varint,79,opt,name=si_frr_active,json=siFrrActive,proto3" json:"si_frr_active,omitempty"`
	SiAttrIsExtMgd        bool                `protobuf:"varint,80,opt,name=si_attr_is_ext_mgd,json=siAttrIsExtMgd,proto3" json:"si_attr_is_ext_mgd,omitempty"`
	SiAttrIsIncomp        bool                `protobuf:"varint,81,opt,name=si_attr_is_incomp,json=siAttrIsIncomp,proto3" json:"si_attr_is_incomp,omitempty"`
	SiAttrIsTunnel        bool                `protobuf:"varint,82,opt,name=si_attr_is_tunnel,json=siAttrIsTunnel,proto3" json:"si_attr_is_tunnel,omitempty"`
	SiAttrIsTunnelSrte    bool                `protobuf:"varint,83,opt,name=si_attr_is_tunnel_srte,json=siAttrIsTunnelSrte,proto3" json:"si_attr_is_tunnel_srte,omitempty"`
	SiAttrIsGreTunnel     bool                `protobuf:"varint,84,opt,name=si_attr_is_gre_tunnel,json=siAttrIsGreTunnel,proto3" json:"si_attr_is_gre_tunnel,omitempty"`
	SiGreTi               uint32              `protobuf:"varint,85,opt,name=si_gre_ti,json=siGreTi,proto3" json:"si_gre_ti,omitempty"`
	SiGreTiFlags          uint32              `protobuf:"varint,86,opt,name=si_gre_ti_flags,json=siGreTiFlags,proto3" json:"si_gre_ti_flags,omitempty"`
	SiGreTiRefcnt         uint32              `protobuf:"varint,87,opt,name=si_gre_ti_refcnt,json=siGreTiRefcnt,proto3" json:"si_gre_ti_refcnt,omitempty"`
	SiGreTosPropagate     bool                `protobuf:"varint,88,opt,name=si_gre_tos_propagate,json=siGreTosPropagate,proto3" json:"si_gre_tos_propagate,omitempty"`
	SiHardware            []byte              `protobuf:"bytes,89,opt,name=si_hardware,json=siHardware,proto3" json:"si_hardware,omitempty"`
	SiNhinfoPtr           uint32              `protobuf:"varint,90,opt,name=si_nhinfo_ptr,json=siNhinfoPtr,proto3" json:"si_nhinfo_ptr,omitempty"`
	SiFnbIdbPtr           uint32              `protobuf:"varint,91,opt,name=si_fnb_idb_ptr,json=siFnbIdbPtr,proto3" json:"si_fnb_idb_ptr,omitempty"`
	SiAncIfh              uint32              `protobuf:"varint,92,opt,name=si_anc_ifh,json=siAncIfh,proto3" json:"si_anc_ifh,omitempty"`
	SiPwhe                *FibShNhinfoPwheExt `protobuf:"bytes,93,opt,name=si_pwhe,json=siPwhe,proto3" json:"si_pwhe,omitempty"`
	SiGreTiResolvingLeafp uint32              `protobuf:"varint,94,opt,name=si_gre_ti_resolving_leafp,json=siGreTiResolvingLeafp,proto3" json:"si_gre_ti_resolving_leafp,omitempty"`
	SiGreDestAddr         []byte              `protobuf:"bytes,95,opt,name=si_gre_dest_addr,json=siGreDestAddr,proto3" json:"si_gre_dest_addr,omitempty"`
	SiNhid                uint32              `protobuf:"varint,96,opt,name=si_nhid,json=siNhid,proto3" json:"si_nhid,omitempty"`
	SiUpdTs               uint64              `protobuf:"varint,97,opt,name=si_upd_ts,json=siUpdTs,proto3" json:"si_upd_ts,omitempty"`
	NhInfoExtension       *FibShNhinfoExt     `protobuf:"bytes,98,opt,name=nh_info_extension,json=nhInfoExtension,proto3" json:"nh_info_extension,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}            `json:"-"`
	XXX_unrecognized      []byte              `json:"-"`
	XXX_sizecache         int32               `json:"-"`
}

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

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

var xxx_messageInfo_FibShNhinfo proto.InternalMessageInfo

func (m *FibShNhinfo) GetSiLinkProto() uint32 {
	if m != nil {
		return m.SiLinkProto
	}
	return 0
}

func (m *FibShNhinfo) GetSiNhinfo() uint32 {
	if m != nil {
		return m.SiNhinfo
	}
	return 0
}

func (m *FibShNhinfo) GetSiNhtype() uint32 {
	if m != nil {
		return m.SiNhtype
	}
	return 0
}

func (m *FibShNhinfo) GetSiIfh() uint32 {
	if m != nil {
		return m.SiIfh
	}
	return 0
}

func (m *FibShNhinfo) GetSiPfiInterfaceType() uint32 {
	if m != nil {
		return m.SiPfiInterfaceType
	}
	return 0
}

func (m *FibShNhinfo) GetSiAdjPtr() uint32 {
	if m != nil {
		return m.SiAdjPtr
	}
	return 0
}

func (m *FibShNhinfo) GetSiAdjPresent() bool {
	if m != nil {
		return m.SiAdjPresent
	}
	return false
}

func (m *FibShNhinfo) GetSiSpecialType() uint32 {
	if m != nil {
		return m.SiSpecialType
	}
	return 0
}

func (m *FibShNhinfo) GetSiRefcount() uint32 {
	if m != nil {
		return m.SiRefcount
	}
	return 0
}

func (m *FibShNhinfo) GetSiFlags() uint32 {
	if m != nil {
		return m.SiFlags
	}
	return 0
}

func (m *FibShNhinfo) GetSiAdjIf() uint32 {
	if m != nil {
		return m.SiAdjIf
	}
	return 0
}

func (m *FibShNhinfo) GetSiExtPfx() []uint32 {
	if m != nil {
		return m.SiExtPfx
	}
	return nil
}

func (m *FibShNhinfo) GetSiExtPfxLen() uint32 {
	if m != nil {
		return m.SiExtPfxLen
	}
	return 0
}

func (m *FibShNhinfo) GetSiExtPfxProto() uint32 {
	if m != nil {
		return m.SiExtPfxProto
	}
	return 0
}

func (m *FibShNhinfo) GetSiAdjAddress() []uint32 {
	if m != nil {
		return m.SiAdjAddress
	}
	return nil
}

func (m *FibShNhinfo) GetSiAdjAddrlen() uint32 {
	if m != nil {
		return m.SiAdjAddrlen
	}
	return 0
}

func (m *FibShNhinfo) GetSiAdjAddrProto() uint32 {
	if m != nil {
		return m.SiAdjAddrProto
	}
	return 0
}

func (m *FibShNhinfo) GetSiAdjRwLen() uint32 {
	if m != nil {
		return m.SiAdjRwLen
	}
	return 0
}

func (m *FibShNhinfo) GetSiAdjRw() []uint32 {
	if m != nil {
		return m.SiAdjRw
	}
	return nil
}

func (m *FibShNhinfo) GetSiDepNhinfoType() uint32 {
	if m != nil {
		return m.SiDepNhinfoType
	}
	return 0
}

func (m *FibShNhinfo) GetSiDepNhinfo() uint32 {
	if m != nil {
		return m.SiDepNhinfo
	}
	return 0
}

func (m *FibShNhinfo) GetSiDepNhinfoIfh() uint32 {
	if m != nil {
		return m.SiDepNhinfoIfh
	}
	return 0
}

func (m *FibShNhinfo) GetSiBkupFrr() uint32 {
	if m != nil {
		return m.SiBkupFrr
	}
	return 0
}

func (m *FibShNhinfo) GetSiProtectFrr() uint32 {
	if m != nil {
		return m.SiProtectFrr
	}
	return 0
}

func (m *FibShNhinfo) GetSiBkupNhinfo() uint32 {
	if m != nil {
		return m.SiBkupNhinfo
	}
	return 0
}

func (m *FibShNhinfo) GetSiBkupIfh() uint32 {
	if m != nil {
		return m.SiBkupIfh
	}
	return 0
}

func (m *FibShNhinfo) GetSiBkupAddr() []uint32 {
	if m != nil {
		return m.SiBkupAddr
	}
	return nil
}

func (m *FibShNhinfo) GetSiBkupAddrlen() uint32 {
	if m != nil {
		return m.SiBkupAddrlen
	}
	return 0
}

func (m *FibShNhinfo) GetSiBkupAddrProto() uint32 {
	if m != nil {
		return m.SiBkupAddrProto
	}
	return 0
}

func (m *FibShNhinfo) GetSiFrrActive() bool {
	if m != nil {
		return m.SiFrrActive
	}
	return false
}

func (m *FibShNhinfo) GetSiAttrIsExtMgd() bool {
	if m != nil {
		return m.SiAttrIsExtMgd
	}
	return false
}

func (m *FibShNhinfo) GetSiAttrIsIncomp() bool {
	if m != nil {
		return m.SiAttrIsIncomp
	}
	return false
}

func (m *FibShNhinfo) GetSiAttrIsTunnel() bool {
	if m != nil {
		return m.SiAttrIsTunnel
	}
	return false
}

func (m *FibShNhinfo) GetSiAttrIsTunnelSrte() bool {
	if m != nil {
		return m.SiAttrIsTunnelSrte
	}
	return false
}

func (m *FibShNhinfo) GetSiAttrIsGreTunnel() bool {
	if m != nil {
		return m.SiAttrIsGreTunnel
	}
	return false
}

func (m *FibShNhinfo) GetSiGreTi() uint32 {
	if m != nil {
		return m.SiGreTi
	}
	return 0
}

func (m *FibShNhinfo) GetSiGreTiFlags() uint32 {
	if m != nil {
		return m.SiGreTiFlags
	}
	return 0
}

func (m *FibShNhinfo) GetSiGreTiRefcnt() uint32 {
	if m != nil {
		return m.SiGreTiRefcnt
	}
	return 0
}

func (m *FibShNhinfo) GetSiGreTosPropagate() bool {
	if m != nil {
		return m.SiGreTosPropagate
	}
	return false
}

func (m *FibShNhinfo) GetSiHardware() []byte {
	if m != nil {
		return m.SiHardware
	}
	return nil
}

func (m *FibShNhinfo) GetSiNhinfoPtr() uint32 {
	if m != nil {
		return m.SiNhinfoPtr
	}
	return 0
}

func (m *FibShNhinfo) GetSiFnbIdbPtr() uint32 {
	if m != nil {
		return m.SiFnbIdbPtr
	}
	return 0
}

func (m *FibShNhinfo) GetSiAncIfh() uint32 {
	if m != nil {
		return m.SiAncIfh
	}
	return 0
}

func (m *FibShNhinfo) GetSiPwhe() *FibShNhinfoPwheExt {
	if m != nil {
		return m.SiPwhe
	}
	return nil
}

func (m *FibShNhinfo) GetSiGreTiResolvingLeafp() uint32 {
	if m != nil {
		return m.SiGreTiResolvingLeafp
	}
	return 0
}

func (m *FibShNhinfo) GetSiGreDestAddr() []byte {
	if m != nil {
		return m.SiGreDestAddr
	}
	return nil
}

func (m *FibShNhinfo) GetSiNhid() uint32 {
	if m != nil {
		return m.SiNhid
	}
	return 0
}

func (m *FibShNhinfo) GetSiUpdTs() uint64 {
	if m != nil {
		return m.SiUpdTs
	}
	return 0
}

func (m *FibShNhinfo) GetNhInfoExtension() *FibShNhinfoExt {
	if m != nil {
		return m.NhInfoExtension
	}
	return nil
}

func init() {
	proto.RegisterType((*FibShNhinfo_KEYS)(nil), "cisco_ios_xr_fib_common_oper.fib.nodes.node.protocols.protocol.vrfs.vrf.nh_info_detail_hardware_egress.nh_info_special_detail_hardware_egress.nh_info_special_punt_detail_hardware_egress.fib_sh_nhinfo_KEYS")
	proto.RegisterType((*FibShNhinfoPwheExt)(nil), "cisco_ios_xr_fib_common_oper.fib.nodes.node.protocols.protocol.vrfs.vrf.nh_info_detail_hardware_egress.nh_info_special_detail_hardware_egress.nh_info_special_punt_detail_hardware_egress.fib_sh_nhinfo_pwhe_ext")
	proto.RegisterType((*FibShFibObjBase)(nil), "cisco_ios_xr_fib_common_oper.fib.nodes.node.protocols.protocol.vrfs.vrf.nh_info_detail_hardware_egress.nh_info_special_detail_hardware_egress.nh_info_special_punt_detail_hardware_egress.fib_sh_fib_obj_base")
	proto.RegisterType((*FibShExtBase)(nil), "cisco_ios_xr_fib_common_oper.fib.nodes.node.protocols.protocol.vrfs.vrf.nh_info_detail_hardware_egress.nh_info_special_detail_hardware_egress.nh_info_special_punt_detail_hardware_egress.fib_sh_ext_base")
	proto.RegisterType((*FibShNhinfoExtRepDet)(nil), "cisco_ios_xr_fib_common_oper.fib.nodes.node.protocols.protocol.vrfs.vrf.nh_info_detail_hardware_egress.nh_info_special_detail_hardware_egress.nh_info_special_punt_detail_hardware_egress.fib_sh_nhinfo_ext_rep_det")
	proto.RegisterType((*FibShNhinfoExtCmnDet)(nil), "cisco_ios_xr_fib_common_oper.fib.nodes.node.protocols.protocol.vrfs.vrf.nh_info_detail_hardware_egress.nh_info_special_detail_hardware_egress.nh_info_special_punt_detail_hardware_egress.fib_sh_nhinfo_ext_cmn_det")
	proto.RegisterType((*FibShNhinfoExtDet)(nil), "cisco_ios_xr_fib_common_oper.fib.nodes.node.protocols.protocol.vrfs.vrf.nh_info_detail_hardware_egress.nh_info_special_detail_hardware_egress.nh_info_special_punt_detail_hardware_egress.fib_sh_nhinfo_ext_det")
	proto.RegisterType((*FibShNhinfoExt)(nil), "cisco_ios_xr_fib_common_oper.fib.nodes.node.protocols.protocol.vrfs.vrf.nh_info_detail_hardware_egress.nh_info_special_detail_hardware_egress.nh_info_special_punt_detail_hardware_egress.fib_sh_nhinfo_ext")
	proto.RegisterType((*FibShNhinfo)(nil), "cisco_ios_xr_fib_common_oper.fib.nodes.node.protocols.protocol.vrfs.vrf.nh_info_detail_hardware_egress.nh_info_special_detail_hardware_egress.nh_info_special_punt_detail_hardware_egress.fib_sh_nhinfo")
}

func init() { proto.RegisterFile("fib_sh_nhinfo.proto", fileDescriptor_aef39e804ffbecc2) }

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

repository: cisco-ie/cisco-proto

repo_name: cisco-ie/cisco-proto