text:
SUMMARY = "GNOME desktop-wide GSettings schemas"
HOMEPAGE = "http://live.gnome.org/gsettings-desktop-schemas"
BUGTRACKER = "https://bugzilla.gnome.org/"

LICENSE = "LGPL-2.1-only"
LIC_FILES_CHKSUM = "file://COPYING;md5=4fbd65380cdd255951079008b364516c"

DEPENDS = "glib-2.0 intltool-native"

GNOMEBASEBUILDCLASS = "meson"
inherit gnomebase gsettings gettext gobject-introspection upstream-version-is-even

EXTRA_OEMESON = "-Dintrospection=true"

def gnome_verdir(v):
    return oe.utils.trim_version(v, 1)

SRC_URI = "${GNOME_MIRROR}/${GNOMEBN}/${@gnome_verdir("${PV}")}/${GNOMEBN}-${PV}.tar.${GNOME_COMPRESS_TYPE};name=archive"

SRC_URI[archive.sha256sum] = "5d5568282ab38b95759d425401f7476e56f8cbf2629885587439f43bd0b84bbe"

license: MIT

repository: brl/citadel

repo_name: brl/citadel

gha_language: BitBake

extension: bb


text:
# Copyright (C) 2012-2014, 2016 Freescale Semiconductor
# Copyright (C) 2015, 2016 O.S. Systems Software LTDA.
# Copyright (C) 2019, 2016 TechNexion Ltd.
# Released under the MIT license (see COPYING.MIT for the terms)

DESCRIPTION = "Packagegroup used by TechNexion to provide a set of runtime utilities"
SUMMARY = "TechNexion packagroup - tools/utilities"

PACKAGE_ARCH = "${MACHINE_ARCH}"

inherit packagegroup

RDEPENDS_${PN} = " \
    parted \
    e2fsprogs-resize2fs \
"

repository: Zondax/meta-tn-imx-bsp

license_type: permissive

repo_name: Zondax/meta-tn-imx-bsp

gha_license_id: MIT


text:
@Article{pmid10376773,
  Author="Alves, S.  and Prata, M. J.  and Ferreira, F.  and Amorim, A. ",
  Title="{{T}hiopurine methyltransferase pharmacogenetics: alternative molecular diagnosis and preliminary data from {N}orthern {P}ortugal}",
  Journal="Pharmacogenetics",
  Year="1999",
  Volume="9",
  Number="2",
  Pages="257--261",
  Month="Apr"
}

repository: larmcr/px

repo_name: larmcr/px

branch_name: refs/heads/master

extension: bib


text:
// Package spi exposes functions and data for reading temperatures from an MSP430 over SPI.
package spi

import "golang.org/x/exp/io/spi"

type Reader struct {
	device *spi.Device
}

// NewReader creates a new SPI reader for the given path.
func NewReader(path string) (*Reader, error) {
	dev, errOpen := spi.Open(&spi.Devfs{
		Dev:      "/dev/spidev0.1",
		Mode:     spi.Mode3,
		MaxSpeed: 12000,
	})

	if errOpen != nil {
		return nil, errOpen
	}

	reader := &Reader{
		device: dev,
	}

	return reader, nil
}

// Close releases all values associated with the Reader.
func (r *Reader) Close() error {
	return r.device.Close()
}

// Read reads values from the SPI device into the given byte slice.
func (r *Reader) Read(b []byte) (int, error) {
	tx := make([]byte, len(b))

	errTx := r.device.Tx(tx, b)
	if errTx != nil {
		return 0, errTx
	}

	return len(b), nil
}

extension: go


text:
require clutter.inc

PV = "0.6.0+svnr${SRCREV}"

SRC_URI = "svn://svn.o-hand.com/repos/clutter/branches;module=clutter-0-6;proto=http \
	   file://enable_tests-0.6.patch;patch=1 "

S = "${WORKDIR}/clutter-0-6"


text:
// totally not stolen from https://github.com/GmdDjca/Hitomi-Manaka
exports.run = (client, message, args) => {
  if (!args[0]) {
    return message.channel.send(`<:error:466995152976871434> pwease incwude some text fow me to owoify UwU`)
  }
  const faces = ['(・`ω´・)', 'x3', 'owo', 'UwU', '>w<', '^w^']
  owoified = `${args.join(' ')}`.replace(/(?:r|l)/g, 'w')
  owoified = owoified.replace(/(?:R|L)/g, 'W')
  owoified = owoified.replace(/n([aeiou])/g, 'ny$1')
  owoified = owoified.replace(/N([aeiou])/g, 'Ny$1')
  owoified = owoified.replace(/N([AEIOU])/g, 'Ny$1')
  owoified = owoified.replace(/ove/g, 'uv')
  owoified = owoified.replace(/!+/g, ' ' + faces[~~(Math.random() * faces.length)] + ' ')

  if(owoified.length > 2000) {
    owoified = owoified.slice(0, -Math.abs(owoified.length - 2000))
  };

message.channel.send(owoified)
};

exports.conf = {
  enabled: true,
  guildOnly: false,
  aliases: [],
  permLevel: "User",
  requiredPerms: []
};

exports.help = {
  name: "owoify",
  category: "Fun",
  description: "Makes nyowmal tewxt owo'ed x3",
  usage: "owoify [message]"
};

repository: woomyware/woomy

repo_name: woomyware/woomy

gha_language: JavaScript

extension: js


text:
#[=======================================================================[.rst:
FindLibnet
----------

Finds the Libnet library.

Imported Targets
^^^^^^^^^^^^^^^^

This module provides the following imported targets, if found:

``Libnet::Libnet``
  The Libnet library

Result Variables
^^^^^^^^^^^^^^^^

This will define the following variables:

``Libnet_FOUND``
  True if the system has the Libnet library.
``Libnet_VERSION``
  The version of the Libnet library which was found.
``Libnet_INCLUDE_DIRS``
  Include directories needed to use Libnet.
``Libnet_LIBRARIES``
  Libraries needed to link to Libnet.

#]=======================================================================]

find_path(Libnet_INCLUDE_DIRS NAMES libnet.h PATH_SUFFIXES libnet)
find_library(Libnet_LIBRARIES NAMES net)
set(Libnet_DEFINITIONS "-D_DEFAULT_SOURCE -DHAVE_NET_ETHERNET_H")
execute_process(COMMAND /bin/sh -c "grep LIBNET_VERSION ${Libnet_INCLUDE_DIRS}/libnet.h | grep -oE '[0-9]+\.[0-9]+\.[0-9]+'"
                OUTPUT_VARIABLE Libnet_VERSION
                OUTPUT_STRIP_TRAILING_WHITESPACE)
set(Libnet_VERSION_STRING ${Libnet_VERSION})

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Libnet
    FOUND_VAR Libnet_FOUND
    REQUIRED_VARS Libnet_INCLUDE_DIRS Libnet_LIBRARIES
    VERSION_VAR Libnet_VERSION)

if(Libnet_FOUND AND NOT TARGET Libnet::Libnet)
    add_library(Libnet::Libnet UNKNOWN IMPORTED)
    target_include_directories(Libnet::Libnet SYSTEM INTERFACE "${Libnet_INCLUDE_DIRS}")
    target_link_libraries(Libnet::Libnet INTERFACE "${Libnet_LIBRARIES}")
    target_compile_definitions(Libnet::Libnet INTERFACE "${Libnet_DEFINITIONS}")
    set_target_properties(Libnet::Libnet PROPERTIES IMPORTED_LOCATION "${Libnet_LIBRARIES}")
endif()

license: NCSA

extension: cmake


text:
DESCRIPTION = "You don't need to load this module yourself in most cases. "Business::ISBN" \
will load it when it loads."

SECTION = "libs"
LICENSE = "Artisticv1 | GPLv1+"
PR = "r0"

MAINTAINER=	"Poky <poky@yoctoproject.org>"
HOMEPAGE=	"https://metacpan.org/release/Business-ISBN-Data"

LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Artistic-1.0;md5=cda03bbdc3c1951996392b872397b798 \
file://${COMMON_LICENSE_DIR}/GPL-1.0;md5=e9e36a9de734199567a4d769498f743d"

SRC_URI = "https://cpan.metacpan.org/authors/id/B/BD/BDFOY/Business-ISBN-Data-20140910.003.tar.gz"

SRC_URI[md5sum] = "e45aba8cb0ed856c8633d874a0bf1f5b"
SRC_URI[sha256sum] = "c756048c9b2b76ae5a7b9f1e1f6c59af670ff89b1fa574d4c3d7e4c9659685c9"

S = "${WORKDIR}/Business-ISBN-Data-${PV}"

inherit cpan allarch

BBCLASSEXTEND = "native"

repository: CELLINKAB/meta-cpan

repo_name: CELLINKAB/meta-cpan


text:
SUMMARY = "KODI-Addons-meta"
inherit packagegroup

ALLOW_EMPTY_${PN} = "1"

RDEPENDS_${PN} = " \
    kodi-addon-pvr-demo \
    kodi-addon-pvr-dvblink \
    kodi-addon-pvr-dvbviewer \
    kodi-addon-pvr-filmon \
    kodi-addon-pvr-hts \
    kodi-addon-pvr-iptvsimple \
    kodi-addon-pvr-mythtv \
    kodi-addon-pvr-nextpvr \
    kodi-addon-pvr-njoy \
    kodi-addon-pvr-pctv \
    kodi-addon-pvr-stalker \
    kodi-addon-pvr-vbox \
    kodi-addon-pvr-vdr.vnsi \
    kodi-addon-pvr-vuplus \
    kodi-addon-pvr-wmc \
    ${@bb.utils.contains("MACHINE_FEATURES", "kodi18", "kodi-addon-inputstream-adaptive kodi-addon-inputstream-rtmp", "", d)} \
    "

repository: neutrino-hd/meta-neutrino

repo_name: neutrino-hd/meta-neutrino


text:
@inproceedings{srds-Barcellos2008a,
 abstract = {BitTorrent is a P2P file-sharing protocol that can be used to efficiently distribute files such as software updates and digital content to very large numbers of users. In a previous paper, we have shown that vulnerabilities can be exploited to launch Denial-of-Service attacks against BitTorrent swarms, which can substantially increase download times and network traffic. In this paper, we review the three most damaging attacks, and propose two algorithms as countermeasures to effectively tackle them. We implemented the attacks and countermeasures in a packet-level BitTorrent simulator. The results indicate that our proposed approach is effective when there is an ongoing attack while at the same time efficient when the countermeasure is active but there is no attack. To the best of our knowledge, this is the first proposal in the literature to make BitTorrent more robust against Denial-of-Service (DoS) attacks. © 2008 IEEE.},
 author = {Barcellos, Marinho P. and Bauermann, Daniel and Sant'Anna, Henrique and Lehmann, Matheus and Mansilha, Rodrigo},
 booktitle = {IEEE SRDS},
 doi = {10.1109/SRDS.2008.26},
 file = {:Users/mbarcell/Google Drive (mbarcell@waikato.ac.nz)/Work/Research/MendeleyPaperBase/Barcellos et al/IEEE SRDS_2008_Barcellos et al.pdf:pdf},
 isbn = {9780769534107},
 issn = {10609857},
 keywords = {Event-based and peer-to-peer infrastructures,Internet-based systems and applications},
 pages = {73--82},
 title = {Protecting BitTorrent: Design and evaluation of effective countermeasures against DoS attacks},
 year = {2008}
}

repository: marinho-barcellos/academic-kickstart

repo_name: marinho-barcellos/academic-kickstart


text:
DESCRIPTION = "uAMQP is a general purpose C library for AMQP"
HOMEPAGE = "https://github.com/Azure/azure-uamqp-c"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=4283671594edec4c13aeb073c219237a"

SRC_URI = "\
    git://github.com/Azure/azure-uamqp-c.git \
"
SRCREV = "142cfab9d66c6f81ea0cceb635f31e00cfa51c77"

PR = "r0"

include ${BPN}.inc

repository: dwalkes/meta-iot-cloud

repo_name: dwalkes/meta-iot-cloud


text:
@article{jagadish2014big,
	title={Big data and its technical challenges},
	author={Jagadish, HV and Gehrke, Johannes and Labrinidis, Alexandros and Papakonstantinou, Yannis and Patel, Jignesh M and Ramakrishnan, Raghu and Shahabi, Cyrus},
	journal={Communications of the ACM},
	volume={57},
	number={7},
	pages={86--94},
	year={2014},
	publisher={ACM}
}
@book{sharda2014businesss,
	title={Businesss Intelligence and Analytics: Systems for Decision Support-(Required)},
	author={Sharda, Ramesh and Delen, Dursun and Turban, Efraim and Aronson, Janine and Liang, Ting Peng},
	year={2014},
	publisher={Prentice Hall London}
}
@article{borkar2006xml,
	title={XML data services},
	author={Borkar, Vinayak and Carey, Michael and Mangtani, Nitin and McKinney, Denny and others},
	journal={International Journal of Web Services Research},
	volume={3},
	number={1},
	pages={85},
	year={2006},
	publisher={IGI Global}
}
@inproceedings{khan2014divide,
	title={DivIDE: efficient diversification for interactive data exploration},
	author={Khan, Hina A and Sharaf, Mohamed A and Albarrak, Abdullah},
	booktitle={Proceedings of the 26th International Conference on Scientific and Statistical Database Management},
	pages={15},
	year={2014},
	organization={ACM}
}
@misc{dillon2013towards,
	title={Towards the Web in Your Pocket: Curated Data as a Service.},
	author={Dillon, Stuart and Stahl, Florian and Vossen, Gottfried},
	year={2013},
	publisher={Springer}
}
@book{fielding2000architectural,
	title={Architectural styles and the design of network-based software architectures},
	author={Fielding, Roy T and Taylor, Richard N},
	year={2000},
	publisher={University of California, Irvine Doctoral dissertation}
}
@inproceedings{sellami2014odbapi,
	title={ODBAPI: a unified REST API for relational and NoSQL data stores},
	author={Sellami, Rami and Bhiri, Sami and Defude, Bruno},
	booktitle={Big Data (BigData Congress), 2014 IEEE International Congress on},
	pages={653--660},
	year={2014},
	organization={IEEE}
}
@inproceedings{ferrari2009database,
	title={Database as a Service: Challenges and solutions for privacy and security},
	author={Ferrari, Elena},
	booktitle={Services Computing Conference, 2009. APSCC 2009. IEEE Asia-Pacific},
	pages={46--51},
	year={2009},
	organization={IEEE}
}
@inproceedings{davidson2008provenance,
	title={Provenance and scientific workflows: challenges and opportunities},
	author={Davidson, Susan B and Freire, Juliana},
	booktitle={Proceedings of the 2008 ACM SIGMOD international conference on Management of data},
	pages={1345--1350},
	year={2008},
	organization={ACM}
}
@inproceedings{hellerstein2017ground,
	title={Ground: A Data Context Service.},
	author={Hellerstein, Joseph M and Sreekanti, Vikram and Gonzalez, Joseph E and Dalton, James and Dey, Akon and Nag, Sreyashi and Ramachandran, Krishna and Arora, Sudhanshu and Bhattacharyya, Arka and Das, Shirshanka and others},
	booktitle={CIDR},
	year={2017}
}
@inproceedings{haupt2015conversation,
	title={A conversation based approach for modeling REST APIs},
	author={Haupt, Florian and Leymann, Frank and Pautasso, Cesare},
	booktitle={Software Architecture (WICSA), 2015 12th Working IEEE/IFIP Conference on},
	pages={165--174},
	year={2015},
	organization={IEEE}
}
@article{hellerstein1999interactive,
	title={Interactive data analysis: The control project},
	author={Hellerstein, Joseph M and Avnur, Ron and Chou, Andy and Hidber, Christian and Olston, Chris and Raman, Vijayshankar and Roth, Tali and Haas, Peter J},
	journal={Computer},
	volume={32},
	number={8},
	pages={51--59},
	year={1999},
	publisher={IEEE}
}
@inproceedings{idreos2015overview,
	title={Overview of data exploration techniques},
	author={Idreos, Stratos and Papaemmanouil, Olga and Chaudhuri, Surajit},
	booktitle={Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
	pages={277--281},
	year={2015},
	organization={ACM}
}
@article{clements2002software,
	title={Software architecture in practice},
	author={Clements, Paul C},
	journal={Diss. Software Engineering Institute},
	year={2002}
}
@inproceedings{tolk2003levels,
	title={The levels of conceptual interoperability model},
	author={Tolk, Andreas and Muguira, James A},
	booktitle={Proceedings of the 2003 fall simulation interoperability workshop},
	volume={7},
	pages={1--11},
	year={2003},
	organization={Citeseer}
}
@inproceedings{page2011rest,
	title={REST and Linked Data: a match made for domain driven development?},
	author={Page, Kevin R and De Roure, David C and Martinez, Kirk},
	booktitle={Proceedings of the Second International Workshop on RESTful Design},
	pages={22--25},
	year={2011},
	organization={ACM}
}
@book{richardson2013restful,
	title={RESTful Web APIs: Services for a Changing World},
	author={Richardson, Leonard and Amundsen, Mike and Ruby, Sam},
	year={2013},
	publisher={" O'Reilly Media, Inc."}
}
@book{wilde2011rest,
	title={REST: from research to practice},
	author={Wilde, Erik and Pautasso, Cesare},
	year={2011},
	publisher={Springer Science \& Business Media}
}
@Inbook{HernÃ¡ndez2011,
	author="Hern{\'a}ndez, Antonio Garrote
	and Garc{\'i}a, Mar{\'i}a N. Moreno",
	editor="Wilde, Erik
	and Pautasso, Cesare",
	title="Metadata Architecture in RESTful Design",
	bookTitle="REST: From Research to Practice",
	year="2011",
	publisher="Springer New York",
	address="New York, NY",
	pages="459--471",
	abstract="Metadata is a key component of the REST architecture that can be used to provide additional information about web resources. The ultimate goal of metadata is to transform web resources into self describing information units that can be automatically processed by software agents. We review the main options present in the HTTP standard to provide metadata for web resources. We also review the main mechanisms proposed by standard organizations like the W3C and the IETF as well as by groups of practitioners to provide additional ways of associating metadata to resources. The connection between metadata and semantic web technologies is also explored. Finally the notion of resource and metadata discovery is also introduced and the main discovery technologies are reviewed.",
	isbn="978-1-4419-8303-9",
	doi="10.1007/978-1-4419-8303-9_21",
	url="https://doi.org/10.1007/978-1-4419-8303-9_21"
}
@Inbook{Robinson2011,
	author="Robinson, Ian",
	editor="Wilde, Erik
	and Pautasso, Cesare",
	title="RESTful Domain Application Protocols",
	bookTitle="REST: From Research to Practice",
	year="2011",
	publisher="Springer New York",
	address="New York, NY",
	pages="61--91",
	abstract="This chapter discusses the significance of domain application protocols in distributed application design and development. Describing an application as an instance of the execution of a domain application protocol, it shows how we can design RESTful APIs that allow clients to drive the execution of a domain application protocol without binding to the protocol itself. The second half of the chapter provides a step-by-step example of a RESTful procurement application; this application realizes a procurement protocol in a way that requires clients to couple simply to media types and link relations, rather than to the protocol.",
	isbn="978-1-4419-8303-9",
	doi="10.1007/978-1-4419-8303-9_3",
	url="https://doi.org/10.1007/978-1-4419-8303-9_3"
}
@inproceedings{idreos2015overview,
	title={Overview of data exploration techniques},
	author={Idreos, Stratos and Papaemmanouil, Olga and Chaudhuri, Surajit},
	booktitle={Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
	pages={277--281},
	year={2015},
	organization={ACM}
}
@misc{dataGov,
	howpublished = "{\url{http://data.gov.au/}}",
	note = "(last verified September2, 2017)"
}
@misc{Amazon,
	howpublished = "{AWS | Amazon SimpleDB – Simple Database Service, \url{http://aws.amazon.com/simpledb/}}",
	note = "(last verified September2, 2017)"
}
@misc{Azure,
	howpublished = "{Microsoft Azure.\url{http://www.microsoft.com/azure/sql.mspx.}}",
	note = "(last verified September2, 2017)"
}
@misc{HTSQL,
	howpublished = "{A Database Query Language-HTSQL, \url{http://htsql.org/.
	}}",
	note = "(last verified September2, 2017)"
}
@misc{PSI,
	howpublished = "{Protocols and structures for inference.\url{http://psi.cecs.anu.edu.au/}}",
	note = "(last verified September2, 2017)"
}
@misc{OData,
	howpublished = "{OData, \url{http://www.odata.org/}}",
	note = "(last verified September2, 2017)"
}
@misc{dataPackage,
	howpublished = "{Data Package-Frictionless Data Specifications, \url{https://specs.frictionlessdata.io/data-package/.
	}}",
	note = "(last verified September2, 2017)"
}
@misc{JSONSchema,
	howpublished = "{JSON Hyper-Schema: A Vocabulary for Hypermedia Annotation of JSON, \url{http://json-schema.org/latest/json-schema-hypermedia.html}}",
	note = "(last verified September2, 2017)"
}
@misc{kaggle,
	howpublished = "{Datasets | Kaggle,\url{https://www.kaggle.com/datasets}}",
	note = "(last verified September2, 2017)"
}
@misc{CKAN,
	howpublished = "{ckan,\url{https://ckan.org/}}",
	note = "(last verified September4, 2017)"
}

@misc{RichardMo,
	howpublished = "{Fowler, M.: Richardson Maturity Model, \url{https://martinfowler.com/articles/richardsonMaturityModel.html}}",
	note = "(last verified September2, 2017)"
}
@misc{AtomPub,
	howpublished = "{Joe Gregorio and Bill de hOra (eds). The Atom Publishing Protocol. 2007,\url{https://bitworking.org/projects/atom/rfc5023.html}}",
	note = "(last verified September5, 2017)"
}
@misc{OpenSearch,
	howpublished = "{OpenSearch,\url{http://www.opensearch.org/Home}}",
	note = "(last verified September5, 2017)"
}

@article{olston2010web,
	title={Web crawling},
	author={Olston, Christopher and Najork, Marc and others},
	journal={Foundations and Trends{\textregistered} in Information Retrieval},
	volume={4},
	number={3},
	pages={175--246},
	year={2010},
	publisher={Now Publishers, Inc.}
}
@inproceedings{wang2010don,
	title={Don't follow me: Spam detection in twitter},
	author={Wang, Alex Hai},
	booktitle={Security and Cryptography (SECRYPT), Proceedings of the 2010 International Conference on},
	pages={1--10},
	year={2010},
	organization={IEEE}
}


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

package gbpserver

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

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

type GBPOperation_OpCode int32

const (
	GBPOperation_ADD     GBPOperation_OpCode = 0
	GBPOperation_REPLACE GBPOperation_OpCode = 1
	GBPOperation_DELETE  GBPOperation_OpCode = 2
)

var GBPOperation_OpCode_name = map[int32]string{
	0: "ADD",
	1: "REPLACE",
	2: "DELETE",
}
var GBPOperation_OpCode_value = map[string]int32{
	"ADD":     0,
	"REPLACE": 1,
	"DELETE":  2,
}

func (x GBPOperation_OpCode) String() string {
	return proto.EnumName(GBPOperation_OpCode_name, int32(x))
}
func (GBPOperation_OpCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_gbp_d0e295495d4347f4, []int{0, 0}
}

// A GBPOperation adds, replaces or deletes a subtree
type GBPOperation struct {
	Opcode               GBPOperation_OpCode `protobuf:"varint,1,opt,name=opcode,enum=gbpserver.GBPOperation_OpCode" json:"opcode,omitempty"`
	ObjectList           []*GBPObject        `protobuf:"bytes,2,rep,name=object_list,json=objectList" json:"object_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GBPOperation) Reset()         { *m = GBPOperation{} }
func (m *GBPOperation) String() string { return proto.CompactTextString(m) }
func (*GBPOperation) ProtoMessage()    {}
func (*GBPOperation) Descriptor() ([]byte, []int) {
	return fileDescriptor_gbp_d0e295495d4347f4, []int{0}
}
func (m *GBPOperation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GBPOperation.Unmarshal(m, b)
}
func (m *GBPOperation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GBPOperation.Marshal(b, m, deterministic)
}
func (dst *GBPOperation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GBPOperation.Merge(dst, src)
}
func (m *GBPOperation) XXX_Size() int {
	return xxx_messageInfo_GBPOperation.Size(m)
}
func (m *GBPOperation) XXX_DiscardUnknown() {
	xxx_messageInfo_GBPOperation.DiscardUnknown(m)
}

var xxx_messageInfo_GBPOperation proto.InternalMessageInfo

func (m *GBPOperation) GetOpcode() GBPOperation_OpCode {
	if m != nil {
		return m.Opcode
	}
	return GBPOperation_ADD
}

func (m *GBPOperation) GetObjectList() []*GBPObject {
	if m != nil {
		return m.ObjectList
	}
	return nil
}

// Version is used for syncing between client and server
type Version struct {
	Number               int32    `protobuf:"varint,1,opt,name=number" json:"number,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Version) Reset()         { *m = Version{} }
func (m *Version) String() string { return proto.CompactTextString(m) }
func (*Version) ProtoMessage()    {}
func (*Version) Descriptor() ([]byte, []int) {
	return fileDescriptor_gbp_d0e295495d4347f4, []int{1}
}
func (m *Version) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Version.Unmarshal(m, b)
}
func (m *Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Version.Marshal(b, m, deterministic)
}
func (dst *Version) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Version.Merge(dst, src)
}
func (m *Version) XXX_Size() int {
	return xxx_messageInfo_Version.Size(m)
}
func (m *Version) XXX_DiscardUnknown() {
	xxx_messageInfo_Version.DiscardUnknown(m)
}

var xxx_messageInfo_Version proto.InternalMessageInfo

func (m *Version) GetNumber() int32 {
	if m != nil {
		return m.Number
	}
	return 0
}

// GBPObject is a generic definition representing an object
type GBPObject struct {
	Subject              string      `protobuf:"bytes,1,opt,name=subject" json:"subject,omitempty"`
	Uri                  string      `protobuf:"bytes,2,opt,name=uri" json:"uri,omitempty"`
	Properties           []*Property `protobuf:"bytes,3,rep,name=properties" json:"properties,omitempty"`
	Children             []string    `protobuf:"bytes,4,rep,name=children" json:"children,omitempty"`
	ParentSubject        string      `protobuf:"bytes,5,opt,name=parent_subject,json=parentSubject" json:"parent_subject,omitempty"`
	ParentUri            string      `protobuf:"bytes,6,opt,name=parent_uri,json=parentUri" json:"parent_uri,omitempty"`
	ParentRelation       string      `protobuf:"bytes,7,opt,name=parent_relation,json=parentRelation" json:"parent_relation,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *GBPObject) Reset()         { *m = GBPObject{} }
func (m *GBPObject) String() string { return proto.CompactTextString(m) }
func (*GBPObject) ProtoMessage()    {}
func (*GBPObject) Descriptor() ([]byte, []int) {
	return fileDescriptor_gbp_d0e295495d4347f4, []int{2}
}
func (m *GBPObject) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GBPObject.Unmarshal(m, b)
}
func (m *GBPObject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GBPObject.Marshal(b, m, deterministic)
}
func (dst *GBPObject) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GBPObject.Merge(dst, src)
}
func (m *GBPObject) XXX_Size() int {
	return xxx_messageInfo_GBPObject.Size(m)
}
func (m *GBPObject) XXX_DiscardUnknown() {
	xxx_messageInfo_GBPObject.DiscardUnknown(m)
}

var xxx_messageInfo_GBPObject proto.InternalMessageInfo

func (m *GBPObject) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *GBPObject) GetUri() string {
	if m != nil {
		return m.Uri
	}
	return ""
}

func (m *GBPObject) GetProperties() []*Property {
	if m != nil {
		return m.Properties
	}
	return nil
}

func (m *GBPObject) GetChildren() []string {
	if m != nil {
		return m.Children
	}
	return nil
}

func (m *GBPObject) GetParentSubject() string {
	if m != nil {
		return m.ParentSubject
	}
	return ""
}

func (m *GBPObject) GetParentUri() string {
	if m != nil {
		return m.ParentUri
	}
	return ""
}

func (m *GBPObject) GetParentRelation() string {
	if m != nil {
		return m.ParentRelation
	}
	return ""
}

// Property is a name value pair, where the value could be one of [string, int, Reference]
type Property struct {
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*Property_StrVal
	//	*Property_IntVal
	//	*Property_RefVal
	Value                isProperty_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *Property) Reset()         { *m = Property{} }
func (m *Property) String() string { return proto.CompactTextString(m) }
func (*Property) ProtoMessage()    {}
func (*Property) Descriptor() ([]byte, []int) {
	return fileDescriptor_gbp_d0e295495d4347f4, []int{3}
}
func (m *Property) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Property.Unmarshal(m, b)
}
func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Property.Marshal(b, m, deterministic)
}
func (dst *Property) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Property.Merge(dst, src)
}
func (m *Property) XXX_Size() int {
	return xxx_messageInfo_Property.Size(m)
}
func (m *Property) XXX_DiscardUnknown() {
	xxx_messageInfo_Property.DiscardUnknown(m)
}

var xxx_messageInfo_Property proto.InternalMessageInfo

type isProperty_Value interface {
	isProperty_Value()
}

type Property_StrVal struct {
	StrVal string `protobuf:"bytes,2,opt,name=strVal,oneof"`
}
type Property_IntVal struct {
	IntVal int32 `protobuf:"varint,3,opt,name=intVal,oneof"`
}
type Property_RefVal struct {
	RefVal *Reference `protobuf:"bytes,4,opt,name=refVal,oneof"`
}

func (*Property_StrVal) isProperty_Value() {}
func (*Property_IntVal) isProperty_Value() {}
func (*Property_RefVal) isProperty_Value() {}

func (m *Property) GetValue() isProperty_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

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

func (m *Property) GetStrVal() string {
	if x, ok := m.GetValue().(*Property_StrVal); ok {
		return x.StrVal
	}
	return ""
}

func (m *Property) GetIntVal() int32 {
	if x, ok := m.GetValue().(*Property_IntVal); ok {
		return x.IntVal
	}
	return 0
}

func (m *Property) GetRefVal() *Reference {
	if x, ok := m.GetValue().(*Property_RefVal); ok {
		return x.RefVal
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Property) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Property_OneofMarshaler, _Property_OneofUnmarshaler, _Property_OneofSizer, []interface{}{
		(*Property_StrVal)(nil),
		(*Property_IntVal)(nil),
		(*Property_RefVal)(nil),
	}
}

func _Property_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Property)
	// value
	switch x := m.Value.(type) {
	case *Property_StrVal:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.StrVal)
	case *Property_IntVal:
		b.EncodeVarint(3<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.IntVal))
	case *Property_RefVal:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RefVal); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Property.Value has unexpected type %T", x)
	}
	return nil
}

func _Property_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Property)
	switch tag {
	case 2: // value.strVal
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Value = &Property_StrVal{x}
		return true, err
	case 3: // value.intVal
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &Property_IntVal{int32(x)}
		return true, err
	case 4: // value.refVal
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Reference)
		err := b.DecodeMessage(msg)
		m.Value = &Property_RefVal{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Property_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Property)
	// value
	switch x := m.Value.(type) {
	case *Property_StrVal:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.StrVal)))
		n += len(x.StrVal)
	case *Property_IntVal:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.IntVal))
	case *Property_RefVal:
		s := proto.Size(x.RefVal)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Reference refers to another GBP object
type Reference struct {
	Subject              string   `protobuf:"bytes,1,opt,name=subject" json:"subject,omitempty"`
	ReferenceUri         string   `protobuf:"bytes,2,opt,name=reference_uri,json=referenceUri" json:"reference_uri,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Reference) Reset()         { *m = Reference{} }
func (m *Reference) String() string { return proto.CompactTextString(m) }
func (*Reference) ProtoMessage()    {}
func (*Reference) Descriptor() ([]byte, []int) {
	return fileDescriptor_gbp_d0e295495d4347f4, []int{4}
}
func (m *Reference) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Reference.Unmarshal(m, b)
}
func (m *Reference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Reference.Marshal(b, m, deterministic)
}
func (dst *Reference) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Reference.Merge(dst, src)
}
func (m *Reference) XXX_Size() int {
	return xxx_messageInfo_Reference.Size(m)
}
func (m *Reference) XXX_DiscardUnknown() {
	xxx_messageInfo_Reference.DiscardUnknown(m)
}

var xxx_messageInfo_Reference proto.InternalMessageInfo

func (m *Reference) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *Reference) GetReferenceUri() string {
	if m != nil {
		return m.ReferenceUri
	}
	return ""
}

func init() {
	proto.RegisterType((*GBPOperation)(nil), "gbpserver.GBPOperation")
	proto.RegisterType((*Version)(nil), "gbpserver.Version")
	proto.RegisterType((*GBPObject)(nil), "gbpserver.GBPObject")
	proto.RegisterType((*Property)(nil), "gbpserver.Property")
	proto.RegisterType((*Reference)(nil), "gbpserver.Reference")
	proto.RegisterEnum("gbpserver.GBPOperation_OpCode", GBPOperation_OpCode_name, GBPOperation_OpCode_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for GBP service

type GBPClient interface {
	// Obtains the objects currently in the policy database as a stream
	ListObjects(ctx context.Context, in *Version, opts ...grpc.CallOption) (GBP_ListObjectsClient, error)
}

type gBPClient struct {
	cc *grpc.ClientConn
}

func NewGBPClient(cc *grpc.ClientConn) GBPClient {
	return &gBPClient{cc}
}

func (c *gBPClient) ListObjects(ctx context.Context, in *Version, opts ...grpc.CallOption) (GBP_ListObjectsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_GBP_serviceDesc.Streams[0], c.cc, "/gbpserver.GBP/ListObjects", opts...)
	if err != nil {
		return nil, err
	}
	x := &gBPListObjectsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type GBP_ListObjectsClient interface {
	Recv() (*GBPOperation, error)
	grpc.ClientStream
}

type gBPListObjectsClient struct {
	grpc.ClientStream
}

func (x *gBPListObjectsClient) Recv() (*GBPOperation, error) {
	m := new(GBPOperation)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for GBP service

type GBPServer interface {
	// Obtains the objects currently in the policy database as a stream
	ListObjects(*Version, GBP_ListObjectsServer) error
}

func RegisterGBPServer(s *grpc.Server, srv GBPServer) {
	s.RegisterService(&_GBP_serviceDesc, srv)
}

func _GBP_ListObjects_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Version)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GBPServer).ListObjects(m, &gBPListObjectsServer{stream})
}

type GBP_ListObjectsServer interface {
	Send(*GBPOperation) error
	grpc.ServerStream
}

type gBPListObjectsServer struct {
	grpc.ServerStream
}

func (x *gBPListObjectsServer) Send(m *GBPOperation) error {
	return x.ServerStream.SendMsg(m)
}

var _GBP_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gbpserver.GBP",
	HandlerType: (*GBPServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListObjects",
			Handler:       _GBP_ListObjects_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "gbp.proto",
}

func init() { proto.RegisterFile("gbp.proto", fileDescriptor_gbp_d0e295495d4347f4) }

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

gha_language: Go


text:
package main

func main() {
	s, l := test[string, uint64](true)
	switch interface{}(s).(type) {
	case string:

	default:
		panic("error")
	}
	switch interface{}(l).(type) {
	case uint64:

	default:
		panic("error")
	}
}

func test[t float64 | string, k int32 | uint64](i bool) (s t, l k) {
	return
}


text:
<?bb
class Animal
  @name
  @age = 18

  def __construct(name)
    @name = name
  end

  def greet
    echo("Hello! I'm " & @name)
  end
end

human = new Animal()
human.greet()

# This is a comment
echo(human.name)

repository: lazytyper/Blueberry

repo_name: lazytyper/Blueberry


text:
@misc{MonitoringAndProtectingSSHSessionsWithEBPF:DBIR,
    author = {Verizon},
    title = {{Data breach investigations report (DBIR)}},
    howpublished = {\url{https://enterprise.verizon.com/resources/reports/2020-data-breach-investigations-report.pdf}},
    year = {2020},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Ext4,
    author = {IOVisor},
    title = {{Summarize ext4 operation latency distribution as a histogram}},
    howpublished = {\url{https://github.com/iovisor/bcc/blob/master/tools/ext4dist.py}},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Ubuntu2FA,
    author = {Ubuntu},
    title = {{Configure SSH to use two-factor authentication}},
    howpublished = {\url{https://ubuntu.com/tutorials/configure-ssh-2fa}},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Twitter,
    author = {Brian Barrett},
    title = {{How Twitter CEO Jack Dorsey's Account Was Hacked}},
    howpublished = {\url{https://www.wired.com/story/jack-dorsey-twitter-hacked}},
    year = {2020},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:MITRE,
    author = {MITRE},
    title = {{Sim card swap}},
    howpublished = {\url{https://attack.mitre.org/techniques/T1451}},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Proofpoint,
    author = {Or Safran and Itir Clarke},
    title = {{New Vulnerabilities Bypass Multi-Factor Authentication for Microsoft 365}},
    howpublished = {\url{https://www.proofpoint.com/us/blog/cloud-security/new-vulnerabilities-bypass-multi-factor-authentication-microsoft-365}},
    year = {2020},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:WSTrust,
    author = {OASIS},
    title = {{WS-Trust 1.4}},
    howpublished = {\url{http://docs.oasis-open.org/ws-sx/ws-trust/v1.4/ws-trust.html}},
    year = {2012},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Titan,
    author = {Victor Lomne and Thomas Roche},
    title = {{A side journey to Titan}},
    howpublished = {\url{https://ninjalab.io/wp-content/uploads/2021/01/a_side_journey_to_titan.pdf}},
    year = {2021},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Chrome,
    author = {Andy Greenberg},
    title = {{Chrome lets hackers phish even “Unphishable” Yubikey users}},
    howpublished = {\url{https://www.wired.com/story/chrome-yubikey-phishing-webusb}},
    year = {2018},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:GoDaddy,
    author = {Davey Winder},
    title = {{GoDaddy Confirms Data Breach: What Customers Need To Know}},
    howpublished = {\url{https://www.forbes.com/sites/daveywinder/2020/05/05/godaddy-confirms-data-breach-what-19-million-customers-need-to-know}},
    year = {2020},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:KernelCapabilities,
    author = {Linux},
    title = {{Kernel capabilities man pages}},
    howpublished = {\url{https://man7.org/linux/man-pages/man7/capabilities.7.html}},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:SSHProbe,
    author = {Guillaume Fournier},
    title = {{ssh-probe source code}},
    howpublished = {\url{https://github.com/Gui774ume/ssh-probe}},
    year = {2021},
}

@article{MonitoringAndProtectingSSHSessionsWithEBPF:BrendanGregg,
    author = {Brendan Gregg},
    title = {{BPF Performance Tools: Linux System and Application Observability}},
    year = {December 2019}
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:SSH,
    author = {IETF},
    title = {{SSH protocol architecture}},
    howpublished = {\url{https://tools.ietf.org/html/rfc4251}},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Facebook,
    author = {Marlon Dutra},
    title = {{Scalable and secure access with SSH}},
    howpublished = {\url{https://engineering.fb.com/2016/09/12/security/scalable-and-secure-access-with-ssh}},
    year = {2016},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Chef,
    author = {Chef},
    title = {{Chef Infrastructure Automation}},
    howpublished = {\url{https://www.chef.io/products/chef-infra}},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Ansible,
    author = {Red Hat Software},
    title = {{Ansible IT automation}},
    howpublished = {\url{https://github.com/ansible/ansible}},
}

@article{MonitoringAndProtectingSSHSessionsWithEBPF:LorenzoDavid,
    author = {Lorenzo Fontana and David Calavera},
    title = {{Linux Observability with BPF}},
    year = {November 2019}
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Kprobes,
    author = {Linux},
    title = {{Kprobe documentation}},
    howpublished = {\url{https://www.kernel.org/doc/Documentation/kprobes.txt}},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Tracepoints,
    author = {Linux},
    title = {{Tracepoint Documentation}},
    howpublished = {\url{https://www.kernel.org/doc/html/latest/trace/tracepoints.html}},
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Uprobes,
    author = {Linux},
    title = {{Uprobe Documentation}},
    howpublished = {\url{https://www.kernel.org/doc/Documentation/trace/uprobetracer.txt}},
}

@article{MonitoringAndProtectingSSHSessionsWithEBPF:NSP,
    author = {Guillaume Fournier},
    title = {{Process level network security monitoring and enforcement with eBPF}},
    journal = {SSTIC},
    year = {2020}
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:Profile,
    author = {Guillaume Fournier},
    title = {{ssh-probe profile example}},
    howpublished = {\url{https://github.com/Gui774ume/ssh-probe/blob/c7364d7eef0a76bc67e35ff3d85768467862a99d/profiles/vagrant.yaml}},
    year = {2021}
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:OverrideReturn,
    author = {Jonathan Corbet},
    title = {{BPF-based error injection for the kernel}},
    howpublished = {\url{https://lwn.net/Articles/740146/}},
    year = {2017}
}

@misc{MonitoringAndProtectingSSHSessionsWithEBPF:KRSI,
    author = {KP Singh},
    title = {{Kernel Runtime Security Instrumentation}},
    howpublished = {\url{https://lwn.net/Articles/798918}},
    year = {2019},
}

repository: syllogy/ssh-probe

repo_name: syllogy/ssh-probe


text:
package main

import (
	"fmt"
	"time"
)

import (
	"golang.org/x/net/context"
)

import (
	"github.com/sanxia/grpc-protobuf/protobuf"
)

/* ================================================================================
 * Server Impl
 * qq group: 582452342
 * email   : 2091938785@qq.com
 * author  : 美丽的地球啊 - mliu
 * ================================================================================ */

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 * 实现RPC OperatorServer接口
 * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
type serverImpl struct{}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 * Add
 * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
func (s *serverImpl) Song(ctx context.Context, in *protobuf.SongRequest) (*protobuf.SongReply, error) {
	lyric := fmt.Sprintf("唱一首%s\x1b[%dm%s\x1b[0m", in.Title, uint8(33), "Meeey Christmas")
	var year uint32 = 2018

	time.Sleep(time.Duration(450 * time.Millisecond))

	return &protobuf.SongReply{Lyric: lyric, Year: year}, nil
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 * Echo
 * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
func (s *serverImpl) MakeAWish(req *protobuf.MakeAWishRequest, server protobuf.Action_MakeAWishServer) error {
	from := fmt.Sprintf("\x1b[%dm%s\x1b[0m", uint8(31), req.From)
	to := fmt.Sprintf("\x1b[%dm%s\x1b[0m", uint8(32), req.To)
	content := fmt.Sprintf("\x1b[%dm%s\x1b[0m", uint8(33), req.Content)
	info := fmt.Sprintf("\x1b[%dm%s\x1b[0m", uint8(36), " 用彩色的蜡笔，祝福 ")

	replyContent := fmt.Sprintf("%s%s%s：%s", from, info, to, content)

	makeAWishReply := &protobuf.MakeAWishReply{
		Content: replyContent,
	}

	time.Sleep(time.Duration(550 * time.Millisecond))

	return server.Send(makeAWishReply)
}

repository: sanxia/grpc-protobuf

repo_name: sanxia/grpc-protobuf


text:
package validator

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestValidateEmptyString(t *testing.T) {
	assert.Panics(t, func() { ValidateParens("") })
}
func TestValidateSingleParen(t *testing.T) {
	assert.False(t, ValidateParens("("))
	assert.False(t, ValidateParens(")"))
}

func TestValidateHappyPath(t *testing.T) {
	assert.True(t, ValidateParens("()"))
	assert.True(t, ValidateParens("()()()()()"))
	assert.True(t, ValidateParens("(()()()()())"))
	assert.True(t, ValidateParens("(()())(()()())"))
}

func TestValidateTooManyClosingParens(t *testing.T) {
	assert.False(t, ValidateParens("())"))
	assert.False(t, ValidateParens("()())"))
	assert.False(t, ValidateParens("())))))"))
}

func TestValidateTooManyOpeningParens(t *testing.T) {
	assert.False(t, ValidateParens("()("))
	assert.False(t, ValidateParens("(()"))
	assert.False(t, ValidateParens("()()("))
	assert.False(t, ValidateParens("()((((((((("))
}

repository: davidlanouette/ValidParentheses

repo_name: davidlanouette/ValidParentheses


text:
DESCRIPTION = "Simple, easy-to-use throttler for asyncio."
HOMEPAGE = "https://github.com/hallazzang/asyncio-throttle"
SECTION = "devel/python"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=c7906e56b70808e1ade6ca05e0bb48d5"

SRC_URI[sha256sum] = "2675282e99d9129ecc446f917e174bc205c65e36c602aa18603b4948567fcbd4"

inherit pypi setuptools3

RDEPENDS:${PN} += "python3-asyncio"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
@misc{javadoc16,
author = {Java Platform Standard Ed. 6 Documentation},
title = {Documentation},
editor = {Oracle},
howpublished = {Internet},
type = {Documentation},
url = {http://download-llnw.oracle.com/javase/6/docs/},
publisher = {Oracle},
year = {2010}
}

@Book{CoDeKaMa2002.1,
  author =	"Francis Cottet and Joëlle Delacroix and Claude Kaiser
		 and Zoubir Mammeri",
  title =	"Scheduling in real-time systems",
  year = 	"2002",
  month = "octobre",
  isbn = {978-0-470-84766-4},
  publisher = "John Wiley and Sons",
  keywords = "SysTrRes",
}

@book{buttazzo1997hard,
  title={{Hard real-time computing systems}},
  author={Buttazzo, G.C. and Buttanzo, G.},
  isbn={0792399943},
  year={1997},
  publisher={Kluwer Norwell, MA}
}

@article{fidge1998real,
  title={{Real-time schedulability tests for preemptive multitasking}},
  author={Fidge, C.J.},
  journal={Real-Time Systems},
  volume={14},
  number={1},
  pages={61--93},
  issn={0922-6443},
  year={1998},
  publisher={Springer}
}

repository: rostgaard/dtu-course-work-archive

repo_name: rostgaard/dtu-course-work-archive


text: @inproceedings{NedelkoskiI_ICDM2020,	author = {Sasho Nedelkoski and Jasmin Bogatinovski and Alexander Acker and Jorge Cardoso and Odej Kao},	booktitle = {20th IEEE International Conference on Data Mining (ICDM), 17-20 November, 2020, Italy},	date-added = {2020-12-14 10:37:07 +0100},	date-modified = {2020-12-14 10:46:07 +0100},	keywords = {https://doi.org/10.1007/978-3-030-44769-4_13},	title = {Self-Attentive Classification-Based Anomaly Detection in Unstructured Logs},	webpdf = {/Papers/CP-2020-094-ICDM_Self_Attentive_Classification_Based_Anomaly_Detection.pdf},	year = {2020}}

gha_language: TeX


text:
require mrtg.inc
SRC_URI[mrtg-2.16.3.md5sum] = "dfdda80c1d575081458cede58f979d81"
SRC_URI[mrtg-2.16.3.sha256sum] = "d5d04b8ab104200d370676813e924470d73cfe12b84380f4e17bc6a44cd498ed"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you 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 cmddeploymentdemplate

import (
	"encoding/json"
	"fmt"
	"os"
	"path"
	"path/filepath"

	"github.com/elastic/cloud-sdk-go/pkg/api/platformapi/configurationtemplateapi"
	"github.com/elastic/cloud-sdk-go/pkg/input"
	"github.com/elastic/cloud-sdk-go/pkg/models"
	sdkcmdutil "github.com/elastic/cloud-sdk-go/pkg/util/cmdutil"
	"github.com/pkg/errors"
	"github.com/spf13/cobra"

	cmdutil "github.com/elastic/ecctl/cmd/util"
	"github.com/elastic/ecctl/pkg/ecctl"
)

const (
	showInstanceConfigurations = "show-instance-configurations"
	stackVersion               = "stack-version"
	filter                     = "filter"
)

// Command represents the top level deployment-template command.
var Command = &cobra.Command{
	Use:     "deployment-template",
	Short:   cmdutil.AdminReqDescription("Manages deployment templates"),
	PreRunE: cobra.MaximumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		cmd.Help()
	},
}

var platformDeploymentTemplateListCmd = &cobra.Command{
	Use:     "list",
	Short:   "Lists the platform deployment templates",
	PreRunE: cobra.MaximumNArgs(0),
	RunE: func(cmd *cobra.Command, args []string) error {
		showInstanceConfig, _ := cmd.Flags().GetBool(showInstanceConfigurations)
		stackVersion, _ := cmd.Flags().GetString(stackVersion)
		metadataFilter, _ := cmd.Flags().GetString(filter)

		res, err := configurationtemplateapi.ListTemplates(configurationtemplateapi.ListTemplateParams{
			API:                ecctl.Get().API,
			ShowInstanceConfig: showInstanceConfig,
			StackVersion:       stackVersion,
			Metadata:           metadataFilter,
		})

		if err != nil {
			return err
		}

		return ecctl.Get().Formatter.Format(filepath.Join("deployment-template", "list"), res)
	},
}

var platformDeploymentTemplateShowCmd = &cobra.Command{
	Use:     "show <template id>",
	Short:   "Shows information about a specific platform deployment template",
	PreRunE: cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		show, _ := cmd.Flags().GetBool("show-instance-configurations")
		res, err := configurationtemplateapi.GetTemplate(configurationtemplateapi.GetTemplateParams{
			TemplateParams: configurationtemplateapi.TemplateParams{
				API: ecctl.Get().API,
				ID:  args[0],
			},
			ShowInstanceConfig: show,
		})

		if err != nil {
			return err
		}

		return ecctl.Get().Formatter.Format(filepath.Join("deployment-template", "show"), res)
	},
}

var platformDeploymentTemplateDeleteCmd = &cobra.Command{
	Use:     "delete <template id>",
	Short:   "Deletes a specific platform deployment template",
	PreRunE: cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		err := configurationtemplateapi.DeleteTemplate(configurationtemplateapi.GetTemplateParams{
			TemplateParams: configurationtemplateapi.TemplateParams{
				API: ecctl.Get().API,
				ID:  args[0],
			},
		})

		if err != nil {
			return err
		}

		fmt.Printf("Successfully deleted deployment template %v \n", args[0])
		return nil
	},
}

var platformDeploymentTemplateCreateCmd = &cobra.Command{
	Use:     "create -f <template file>.json",
	Short:   "Creates a platform deployment template",
	PreRunE: cobra.MaximumNArgs(0),
	RunE: func(cmd *cobra.Command, args []string) error {
		if err := sdkcmdutil.FileOrStdin(cmd, "file-template"); err != nil {
			return err
		}

		tc, err := parseTemplateFile(cmd.Flag("file-template").Value.String())
		if err != nil {
			return err
		}

		if id := cmd.Flag("id").Value.String(); id != "" {
			tc.ID = id
		}

		tid, err := configurationtemplateapi.CreateTemplate(configurationtemplateapi.CreateTemplateParams{
			DeploymentTemplateInfo: tc,
			API:                    ecctl.Get().API,
		})

		if err != nil {
			return err
		}

		fmt.Printf("Successfully created deployment template %v \n", tid)
		return nil

	},
}

var platformDeploymentTemplateUpdateCmd = &cobra.Command{
	Use:     "update <template id> -f <template file>.json",
	Short:   "Updates a platform deployment template",
	PreRunE: cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		if err := sdkcmdutil.FileOrStdin(cmd, "file-template"); err != nil {
			return err
		}
		tc, err := parseTemplateFile(cmd.Flag("file-template").Value.String())
		if err != nil {
			return err
		}
		if err := configurationtemplateapi.UpdateTemplate(
			configurationtemplateapi.UpdateTemplateParams{
				TemplateParams: configurationtemplateapi.TemplateParams{
					API: ecctl.Get().API,
					ID:  args[0],
				},

				DeploymentTemplateInfo: tc,
			},
		); err != nil {
			return err
		}

		fmt.Printf("Successfully updated deployment template %v \n", args[0])
		return nil

	},
}

var platformDeploymentTemplatePullCmd = &cobra.Command{
	Use:     "pull --path <path>",
	Short:   "Downloads deployment template into a local folder",
	PreRunE: cobra.MaximumNArgs(0),

	RunE: func(cmd *cobra.Command, args []string) error {
		return configurationtemplateapi.PullToFolder(configurationtemplateapi.PullTemplateToFolderParams{
			TemplateToFolderParams: configurationtemplateapi.TemplateToFolderParams{
				API:    ecctl.Get().API,
				Folder: cmd.Flag("path").Value.String(),
			},
		})
	},
}

func parseTemplateFile(fp string) (*models.DeploymentTemplateInfo, error) {
	if fp != "" {
		if ext := path.Ext(fp); ext != ".json" {
			return nil, errors.New("unsupported file type, only json template files are currently supported")
		}
	}

	templateFile, err := input.NewFileOrReader(os.Stdin, fp)
	if err != nil {
		return nil, err
	}
	defer templateFile.Close()

	var templateConfiguration models.DeploymentTemplateInfo
	if err := json.NewDecoder(templateFile).Decode(&templateConfiguration); err != nil {
		return nil, err
	}

	return &templateConfiguration, nil
}

func init() {
	Command.AddCommand(
		platformDeploymentTemplateListCmd,
		platformDeploymentTemplateShowCmd,
		platformDeploymentTemplateDeleteCmd,
		platformDeploymentTemplateCreateCmd,
		platformDeploymentTemplateUpdateCmd,
		platformDeploymentTemplatePullCmd,
	)

	platformDeploymentTemplateShowCmd.Flags().BoolP(showInstanceConfigurations, "", false, "Shows instance configurations")

	platformDeploymentTemplateListCmd.Flags().BoolP(showInstanceConfigurations, "", false, "Shows instance configurations - only visible when using the JSON output")
	platformDeploymentTemplateListCmd.Flags().String(stackVersion, "", "If present, it will cause the returned deployment templates to be adapted to return only the elements allowed in that version.")
	platformDeploymentTemplateListCmd.Flags().String(filter, "", "Optional key/value pair in the form of key:value that will act as a filter and exclude any templates that do not have a matching metadata item associated")

	platformDeploymentTemplateCreateCmd.Flags().StringP("file-template", "f", "", "YAML or JSON file that contains the deployment template configuration")
	platformDeploymentTemplateCreateCmd.Flags().String("id", "", "Optional ID to set for the deployment template (Overrides ID if present)")

	platformDeploymentTemplateUpdateCmd.Flags().StringP("file-template", "f", "", "YAML or JSON file that contains the deployment template configuration")

	platformDeploymentTemplatePullCmd.Flags().StringP("path", "p", "", "Local path where to store deployment templates")
	platformDeploymentTemplatePullCmd.MarkFlagRequired("path")
}

repository: karencfv/ecctl

repo_name: karencfv/ecctl


text:
@article{ebden2015kestrel,
  title={The Kestrel TTS text normalization system},
  author={Ebden, Peter and Sproat, Richard},
  journal={Natural Language Engineering},
  volume={21},
  number={3},
  pages={333},
  year={2015},
  publisher={Cambridge University Press}
}

@article{sproat2016rnn,
  title={RNN approaches to text normalization: A challenge},
  author={Sproat, Richard and Jaitly, Navdeep},
  journal={arXiv preprint arXiv:1611.00068},
  year={2016}
}

@book{taylor2009text,
  title={Text-to-speech synthesis},
  author={Taylor, Paul},
  year={2009},
  publisher={Cambridge university press}
}

repository: dertilo/NeMo

repo_name: dertilo/NeMo

branch_name: refs/heads/main


text:
DESCRIPTION = "Service utils"
LICENSE = "MIT"
PR = "r9"

PACKAGE_ARCH = "${MACHINE_ARCH}"

inherit packagegroup

ARAGO_DEBUG = "\
    htop \
    socat \
    util-linux \
    openssh-sftp-server \
    gdbserver \
    openssh \
    valgrind \
    e2fsprogs \
    nano \
    "

# minimal set of packages - needed to boot
RDEPENDS_${PN} = "\
    ${ARAGO_DEBUG} \
    "

repository: Technokom/meta-tk-ti

repo_name: Technokom/meta-tk-ti


text:
#
# base recipe: meta/recipes-multimedia/alsa/alsa-lib_1.0.27.2.bb
# base branch: daisy
#

PR = "r0"

inherit debian-package

LICENSE = "LGPLv2.1 & GPLv2"
LIC_FILES_CHKSUM = " \
	file://COPYING;md5=7fbc338309ac38fefcd64b04bb903e34 \
	file://src/conf/sndo-mixer.alisp;beginline=4;endline=5;md5=74fd906517c182ba9b673a01fd1cc412 \
"

# make Check-if-wordexp-function-is-supported.patch compatible with
# debian version
#
# exclude Update-iatomic.h-functions-definitions-for-mips.patch
# because atomic_add, atomic_sub, atomic_add_return, atomic_sub_return
# were already removed from iatomic.h
#
# exclude fix-tstamp-declaration.patch because there is no error
# "error: field 'tstamp' has incomplete type"
SRC_URI += " \
file://Check-if-wordexp-function-is-supported_debian.patch \
"

# configure.in sets -D__arm__ on the command line for any arm system
# (not just those with the ARM instruction set), this should be removed,
# (or replaced by a permitted #define).
#FIXME: remove the following
ARM_INSTRUCTION_SET = "arm"

inherit autotools pkgconfig

EXTRA_OECONF = " \
	${@get_alsa_fpu_setting(bb, d)} \
	--disable-static --disable-python \
"

EXTRA_OECONF_append_libc-uclibc = " --with-versioned=no "

PACKAGES =+ "alsa-server libasound alsa-conf-base alsa-conf alsa-doc alsa-dev"
FILES_${PN} += "${libdir}/${BPN}/smixer/*.so"
FILES_${PN}-dbg += "${libdir}/${BPN}/smixer/.debug"
FILES_${PN}-dev += "${libdir}/${BPN}/smixer/*.la"
FILES_libasound = "${libdir}/libasound.so.*"
FILES_alsa-server = "${bindir}/*"
FILES_alsa-conf = "${datadir}/alsa/"
FILES_alsa-dev += "${libdir}/pkgconfig/ ${includedir}/alsa ${datadir}/aclocal/*"
FILES_alsa-conf-base = "\
${datadir}/alsa/alsa.conf \
${datadir}/alsa/cards/aliases.conf \
${datadir}/alsa/pcm/default.conf \
${datadir}/alsa/pcm/dmix.conf \
${datadir}/alsa/pcm/dsnoop.conf"

RDEPENDS_libasound = "alsa-conf-base"

def get_alsa_fpu_setting(bb, d):
    if d.getVar('TARGET_FPU', True) in [ 'soft' ]:
        return "--with-softfloat"
    return ""

BBCLASSEXTEND = "native nativesdk"

repository: nghiaht-tsdv/meta-debian

repo_name: nghiaht-tsdv/meta-debian

branch_name: refs/heads/jethro


text:
@ARTICLE{Bravetal2010,
  author = {Brav, Alon and  J.B. Heaton and Si Li},
  title = {The Limits of the Limits of Arbitrage},
  journal = {Review of Finance},
  year = {2010},
  volume = {14 (1)},
  pages = {157--187}
}

@ARTICLE{LiLu2010,
  author = {Li, Dongmei and Lu Zhang},
  title = {Does Q-theory with Investment Frictions Explain Anomalies in the Cross Section of returns?},
  journal = {Journal of Financial Economics},
  year = {2010},
  volume = {98 (2)},
  pages = {297--314}
}

@ARTICLE{LoughranRitter2000,
  author = {Loughran, Tim and Jay Ritter},
  title = {Uniformly Least Powerful Tests of Market Efficiency},
  journal = {Journal of Financial Economics},
  year = {2000},
  volume = {55 (3)},
  pages = {361--389}
}

@ARTICLE{JegadeeshTitman1993,
  author = {Jegadeesh, Narasimhan and Sheridan Titman},
  title = {Returns to Buying Winnners and Selling Losers: Implications for Stock Market Efficiency},
  journal = {Journal of Finance},
  year = {1993},
  volume = {48 (1)},
  pages = {65--91}
}

@ARTICLE{Bravetal2005,
  author = {Brav, Alon and  John R. Graham and  Campbell R. Harvey and Roni Michaely},
  title = {Payout policy in the 21st century},
  journal = {Journal of Financial Economics},
  year = {2005},
  volume = {77 (3)},
  pages = {483--527}
}

@ARTICLE{Bravetal2000,
  author = {Brav, Alon and  Christopher Geczy and  Paul A. Gompers},
  title = {Is the abnormal return following equity issuances anomalous?},
  journal = {Journal of Financial Economics},
  year = {2000},
  volume = {56 (2)},
  pages = {209--249}
}

@ARTICLE{StephensWeisbach1998,
  title={Actual Share Reacquisitions in Open-Market Repurchase Programs},
  author={Stephens, P. Clifford and Michael Weisbach},
  journal={The Journal of Finance},
  year={1998},
  volume={53 (1)},
  pages={313--333},
  publisher={Wiley Online Library}
}

@ARTICLE{NovyMarx2013,
  author = {Robert Novy-Marx},
  title = {The other side of value: The gross profitability premium},
  journal = {Journal of Financial Economics},
  year = {2013},
  volume = {108 (1)},
  pages = {1--28}
}

@ARTICLE{Eckboetal2000,
  author = {Eckbo, B. Espen and Ronald W. Masulis and $\O$yvind Norli},
  title = {Seasoned public offerings: resolution of the 'new issues puzzle'},
  journal = {Journal of Financial Economics},
  year = {2000},
  volume = {56 (2)},
  pages = {251--291}
}

@ARTICLE{DittmarThakor2007,
  author={Dittmar, Amy and Anjan Thakor},
  title={Why Do Firms Issue Equity?},
  journal={The Journal of Finance},
  year={2007},
  volume={62 (1)},
  pages={1--54},
  publisher={Wiley Online Library}
}

@ARTICLE{GaoRitterZhu2013,
  author={Gao, Xiaohui and Jay R. Ritter and Zhongyan Zhu},
  title={Where Have All the IPOs Gone?},
  journal={The Journal of Finance},
  year={2013},
  volume={48 (6)},
  pages={1663--1892},
  publisher={Wiley Online Library}
}

@ARTICLE{FamaFrench2015,
  author = {Fama, F. Eugene and Kenneth R. French},
  title = {A five-factor asset pricing model},
  journal = {Journal of Financial Economics},
  year = {2015},
  volume = {116 (1)},
  pages = {1--22}
}

@article{WangYu2013,
  title={Dissecting the Profitability Premium},
  author={Wang, Huijun and Yu Yuan},
  journal={Unpublished working paper},
  year={2013}
}

@article{StambaughYuan2016,
  title={Mispricing Factors},
  author={Stambaugh, F. Robert and Yu Yuan},
  journal={Unpublished working paper},
  year={2016}
}

@article{Cilibertietal2015,
  title={Deconstructing the Low-Vol Anomaly},
  author={Ciliberti, S. and Y. Lempérière and  A. Beveratos and  G. Simon and  L. Laloux and  M. Potters and  J. P. Bouchaud},
  journal={Unpublished working paper},
  year={2015}
}

@article{FamaFrench2016,
  title={Dissecting anomalies with a five-factor model},
  author={Fama, F. Eugene and Kenneth R. French},
  journal = {The Review of Financial Studies},
  year = {2016},
  volume={29 (1)},
  pages={69--103}
}

@article{Alietal2003,
  title={Arbitrage risk and the book-to-market anomaly},
  author={Ali, Ashiq and Lee-Seok Hwang and Mark A. Trombley},
  journal = {Journal of Financial Economics},
  year = {2003},
  volume={69 (2)},
  pages={355--373}
}

@article{Mendenhall2004,
  title={Arbitrage Risk and Post-Earnings-Announcement Drift},
  author={Mendenhall,R. Richard},
  journal = {The Journal of Business},
  year = {2004},
  volume={77 (4)},
  pages={875--894}
}

@article{Pontiff1996,
  title={Costly Arbitrage: Evidence from Closed-End Funds},
  author={Pontiff,Jeffrey},
  journal = {The Quarterly Journal of Economics},
  year = {1996},
  volume={111 (4)},
  pages={1135--1151}
}

@ARTICLE{McLean2016,
  title={Does academic research destroy stock return predictability?},
  author={McLean, R. David  and Jeffrey Pontiff},
  journal={The Journal of Finance},
  year={2016},
  volume={71 (1)},
  pages={5--32},
  publisher={Wiley Online Library}
}

@ARTICLE{LiRodneyGarcia2016,
  title={The Low-Volatility Anomaly: Market Evidence on Systematic Risks versus Mispricing},
  author={Li, Xi and Rodney N. Sullivan and Luis Garcia-Feijoo},
  journal={Financial Analyst Journal},
  year={2016},
  volume={72 (1)},
  pages={36--47}
}

@article{Ibbotson1975,
  title={Price performance of common stock new issues},
  author={Ibbotson, G. Roger },
  journal={Journal of Financial Economics},
  volume={2 (3)},
  pages={235--272},
  year={1975},
  publisher={Elsevier}
}

@article{Linetal2014,
  title={Limited attention, share repurchases, and takeover risk},
  author={Lin, Ji-Chai and Clifford P. Stephens and YiLin Wu},
  journal={Journal of Banking and Finance},
  volume={42},
  pages={283--301},
  year={2014},
  publisher={Elsevier}
}

@ARTICLE{LiRajgopaletal2014,
  title={$R^2$ and Idiosyncratic Risk are not Inter-Changeable},
  author={Li, Bin and Shivaram Rajgopal and Mohan Venkatachalam},
  journal={The Accounting Review},
  year={2014},
  volume={89 (6)},
  pages={2261--2295},
  publisher={Wiley Online Library}
}

@ARTICLE{DeLongetal1990,
  author = {De Long,J. Bradford and Andrei Shleifer and Lawrence H. Summers and Robert J. Waldmann},
  title = {Noise Trader Risk in Financial Markets},
  journal = {The Journal of Political Economy},
  year = {1990},
  volume = {98 (4)},
  pages = {703--738},
  number = {5}
}

@ARTICLE{ShleiferVishny1997,
  author = {Andrei Shleifer and Robert W. Vishny},
  title = {The Limits of Arbitrage},
  journal = {Journal of Finance},
  year = {1997},
  volume = {52 (1)},
  pages = {35--55},
  number = {1}
}

@ARTICLE{Stambaugh2015,
  title={Arbitrage asymmetry and the idiosyncratic volatility puzzle},
  author={Stambaugh, F. Robert  and Jianfeng Yu  and Yu Yuan},
  journal={The Journal of Finance},
  year={2015},
  volume={70 (5)},
  pages={1903--1948},
  publisher={Wiley Online Library}
}

@ARTICLE{Ang2006,
  title={The cross-section of volatility and expected returns},
  author={Ang, Andrew and Robert J. Hodrick and Yuhang Xing  and Xiaoyan Zhang},
  journal={The Journal of Finance},
  volume={61 (1)},
  pages={259--299},
  year={2006},
  publisher={Wiley Online Library}
}

@ARTICLE{Carhart1997,
  title={On persistence in mutual fund performance},
  author={Carhart, Mark},
  journal={The Journal of Finance},
  volume={52 (1)},
  pages={57--82},
  year={1997},
  publisher={Wiley Online Library}
}

@ARTICLE{FamaFrench1993,
  author = {Fama, F. Eugene  and Kenneth R. French},
  title = {Common Risk Factors in the Returns of Stocks and Bonds},
  journal = {Journal of Financial Economics},
  year = {1993},
  volume = {33 (1)},
  pages = {3--56}
}

@ARTICLE{FuHuang2016,
  author = {Fu, Fangjian and Sheng Huang},
  title = {The Persistence of Long-Run Abnormal Returns Following Stock Repurchases and Offerings},
  journal = {Management Science},
  volume = {62 (4)},
  pages = {964--984},
  year = {2016}
}

@ARTICLE{FamaFrench2001,
  author = {Fama, F. Eugene and  Kenneth R. French},
  title = {Disappearing dividends: changing firm characteristics or lower propensity to pay?},
  journal = {Journal of Financial Economics},
  year = {2001},
  volume = {60 (1)},
  pages = {3--43}
}

@ARTICLE{IkenberryVermaelen1996,
  author = {Ikenberry, David and Theo Vermaelen},
  title = {The option to repurchase stock},
  journal = {Financial Management},
  year = {1996},
  volume = {25 (4)},
  pages = {9--24}
}

@ARTICLE{IkenberryLakonishokVermaelen1995,
  author = {Ikenberry, David  and Josef Lakonishok and Theo Vermaelen},
  title = {Market underreaction to open market share repurchases},
  journal = {Journal of Financial Economics},
  year = {1995},
  volume = {39 (2-3)},
  pages = {181--208}
}

@ARTICLE{LakonishokVermaelen1990,
  author = {Lakonishok, Josef and Theo Vermaelen},
  title = {Anomalous Price Behavior Around Repurchase Tender Offers},
  journal = {Journal of Finance},
  year = {1990},
  volume = {45 (2)},
  pages = {455--477},
  number = {2}
}

@ARTICLE{LoughranRitter1995,
  author = {Loughran, Tim and Jay Ritter},
  title = {The New Issues Puzzle},
  journal = {Journal of Finance},
  year = {1995},
  volume = {50 (1)},
  pages = {23--51},
  number = {1}
}

@ARTICLE{Vermaelen1981,
  author = {Vermaelen, Theo},
  title = {Common stock repurchases and market signaling: an empirical study},
  journal = {Journal of Financial Economics},
  year = {1981},
  volume = {9 (2)},
  pages = {139--183}
}

@ARTICLE{BhattacharyaJacobsen2016,
  author = {Bhattacharya, U. and S.E. Jacobsen},
  title = {The share repurchase announcement puzzle},
  journal = {Review of Finance},
  year = {2016},
  volume = {20 (2)},
  pages = {725--758}
}

@ARTICLE{ManconiPeyerVermaelen2015,
  author = {Manconi, Alberto and Urs Peyer	and Theo Vermaelen},
  title = {Buybacks Around the World Market Timing, Governance and Regulation},
  journal = {Unpublished working paper. INSEAD, France},
  year = {2015},
  volume = {},
  pages = {},
  number = {}
}

@ARTICLE{GrullonMichaely2004,
  author = {Grullon, Gustavo and Roni Michaely},
  title = {The Information Content of Share Repurchase Program},
  journal = {Journal of Finance},
  year = {2004},
  volume = {59 (2)},
  pages = {651-680},
  number = {2}
}

@ARTICLE{Liuetal2009,
  author = {Liu, Xiaolei Laura and Toni M. Whited and Lu Zhang},
  title = {Investment Based Expected Stock Returns},
  journal = {Journal of Political Economy},
  year = {2009},
  volume = {117 (6)},
  pages = {1105--1139},
  number = {6}
}

@ARTICLE{Lietal2009,
  author = {Li, X. N. Erica and Dmitry Livdan and Lu Zhang},
  title = {Anomalies},
  journal = {The Review of Financial Studies},
  year = {2009},
  volume = {22 (11)},
  pages = {4301--4334},
  number = {11}
}

@ARTICLE{MitchellStafford2000,
  author = {Mitchell, Mark and Eric Stafford},
  title = {Managerial Decisions and Long-Term Stock Price Performance},
  journal = {The Journal of Business},
  year = {2000},
  volume = {73 (3)},
  pages = {287--329},
  number = {3}
}

@ARTICLE{MitchellPulvino2001,
  author = {Mitchell, Mark and Todd Pulvino},
  title = {Characteristics of Risk and Return in Risk Arbitrage},
  journal = {Journal of Finance},
  year = {2001},
  volume = {56 (6)},
  pages = {2135--2175},
  number = {6}
}

@ARTICLE{Houetal2015,
  author = {Hou, Kewei and Chen Xue and Lu Zhang},
  title = {Digesting anomalies: An investment approach },
  journal = {The Review of Financial Studies},
  year = {2015},
  volume = {28 (3)},
  pages = {650--705},
  number = {3}
}

@ARTICLE{PeyerVermaelen2009,
  author = {Peyer, Urs and Theo Vermaelen},
  title = {The Nature and Persistence of Buyback Anomalies},
  journal = {The Review of Financial Studies},
  year = {2009},
  volume = {22 (4)},
  pages = {1693--1745},
  number = {4}
}

@ARTICLE{SpiessAffleckGraves1995,
  author = {Spiess, D. Katherine and John Affleck-Graves},
  title = {Underperformance in long-run stock returns following seasoned equity offerings},
  journal = {Journal of Financial Economics},
  year = {1995},
  volume = {38 (3)},
  pages = {243--267}
}

@ARTICLE{VermaelenXu2014,
  author = {Vermaelen, Theo and Moqi Xu},
  title = {Acquisition finance and market timing},
  journal = {Journal of Corporate Finance},
  year = {2014},
  volume = {25},
  pages = {73--91},
  number = {}
}

repository: YesDrX/FinanceProjectTemplate

repo_name: YesDrX/FinanceProjectTemplate


text:
SUMMARY = "Example recipe for using inherit useradd"
DESCRIPTION = "This recipe serves as an example for using features from useradd.bbclass"
SECTION = "examples"
PR = "r1"
LICENSE = "MIT"

S = "${WORKDIR}"

inherit useradd

# You must set USERADD_PACKAGES when you inherit useradd. This
# lists which output packages will include the user/group
# creation code.
USERADD_PACKAGES = "${PN}"

# You must also set USERADD_PARAM and/or GROUPADD_PARAM when
# you inherit useradd.

# USERADD_PARAM specifies command line options to pass to the
# useradd command. Multiple users can be created by separating
# the commands with a semicolon. Here we'll create two users,
# user1 and user2:
USERADD_PARAM_${PN} = "-u 1000 -d /home/pi -r -s /bin/sh pi"

do_install () {
        install -d -m 755 ${D}/home/pi
	chown -R pi ${D}/home/pi
	chgrp -R pi ${D}/home/pi
}

FILES_${PN} = "/home/pi"

repository: BechirZalila/meta-example

repo_name: BechirZalila/meta-example


text:
/*
CSI Driver for Linstor
Copyright © 2018 LINBIT USA, LLC

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, see <http://www.gnu.org/licenses/>.
*/

package linstor

import lc "github.com/LINBIT/golinstor"

const (
	// AnnotationsKey is the Aux props key in linstor where serialized CSI volumes
	// are stored.
	AnnotationsKey = lc.NamespcAuxiliary + "/csi-volume-annotations"

	// PropertyCreatedFor is the Aux props key in linstor used to identify why a specific object (for example, a
	// resource) exists.
	PropertyCreatedFor = lc.NamespcAuxiliary + "/csi-created-for"

	// CreatedForTemporaryDisklessAttach marks a resource as temporary, i.e. it should be removed after it is no longer
	// needed.
	CreatedForTemporaryDisklessAttach = "temporary-diskless-attach"
)

repository: timyinshi/linstor-csi

repo_name: timyinshi/linstor-csi


text:
'use strict';

describe('threadsettings', () => {

    let UserProfile, up, request;

    beforeEach(() => {
        const proxyquire = require('proxyquire');

        request = {
            get : jasmine.createSpy('request.get')
        };

        let api = proxyquire('../../src/userprofile.js', { request : request });
        UserProfile         = api.UserProfile;
        up = new UserProfile();
    });

    describe('constructor', () => {
        it('initializes', () => {
            expect(up.endpoint).toEqual('https://graph.facebook.com/v2.6');
        });
    });

    describe('.getProfile', () => {
        let userId, accessToken;
        beforeEach(()=>{
            userId = 'user-1';
            accessToken = 'token-1';

            request.get.and.callFake((opts,cb) => {
                return cb(null, {}, { first_name : 'howard', last_name : 'cool' });
            });
        });

        it('gets a userProfile', (done) => {
            up.getProfile(userId, accessToken)
            .then((v) => {
                let opts = request.get.calls.argsFor(0)[0];
                expect(opts.qs.access_token).toEqual('token-1');
                expect(opts.url).toEqual('https://graph.facebook.com/v2.6/user-1');
                expect(opts.json).toEqual(true);
                expect(v).toEqual({ first_name : 'howard', last_name : 'cool' });
            })
            .then(done, done.fail);
        });

        it('rejects if the request fails with an error', (done) => {
            let e = new Error('fail');
            request.get.and.callFake((opts,cb) => {
                return cb(e);
            });

            up.getProfile(userId, accessToken)
            .then(done.fail, (err) => {
                expect(err).toBe(e);
            })
            .then(done, done.fail);
        });

        it('rejects if the request statusCode is not 2xx', (done) => {
            request.get.and.callFake((opts,cb) => {
                return cb(null, { statusCode : 400 }, { msg : 'fail' });
            });

            up.getProfile(userId, accessToken)
            .then(done.fail, (err) => {
                expect(err.message)
                    .toEqual('Unexpected statusCode: 400 - { msg: \'fail\' }');
            })
            .then(done, done.fail);
        });
    });
});

repository: howardengelhart/thefacebook

repo_name: howardengelhart/thefacebook


text:
import React from 'react';
import { createNativeStackNavigator } from '@react-navigation/native-stack';
import Dashboard from '../containers/dashboard';
import headerOptions from './header';
import i18n from '../shared/i18n';

const Stack = createNativeStackNavigator();

export default function DashboardStack() {
  return (
    <Stack.Navigator initialRouteName="base-main" {...headerOptions}>
      <Stack.Screen
        name="base-main"
        component={Dashboard}
        options={{ title: i18n.t('dashboard') }}
      />
    </Stack.Navigator>
  );
}

repository: pdpino/worktime-mobile

repo_name: pdpino/worktime-mobile


text:
require linux.inc

DESCRIPTION = "2.6.27 Linux kernel for the Pandora handheld console"
KERNEL_IMAGETYPE = "uImage"

COMPATIBLE_MACHINE = "omap3-pandora"

SRCREV = "de97a300975433c0ebbc53f2c35eff4e492afd84"

SRC_URI = " \
           git://git.openpandora.org/pandora-kernel.git;protocol=git;branch=pandora-27-omap1 \
"

# -------------------------------

PV = "2.6.27-pandora+${PR}+git${SRCREV}.3"

SRC_URI_append = " \
           file://defconfig \
           file://0001-Add-EHCI-patch-suggested-by-Steven-Kipisz.patch;patch=1 \
           file://0002-Add-missing-define-to-EHCI-OMAP.c.patch;patch=1 \
           file://no-empty-flash-warnings.patch;patch=1 \
           file://oprofile-0.9.3.armv7.diff;patch=1 \
           file://no-cortex-deadlock.patch;patch=1 \
           file://read_die_ids.patch;patch=1 \
           file://fix-install.patch;patch=1 \
           file://mru-fix-timings.diff;patch=1 \
           file://mru-fix-display-panning.diff;patch=1 \
           file://mru-make-dpll4-m4-ck-programmable.diff;patch=1 \
           file://mru-improve-pixclock-config.diff;patch=1 \
           file://mru-make-video-timings-selectable.diff;patch=1 \
           file://mru-enable-overlay-optimalization.diff;patch=1 \
           file://dvb-fix-dma.diff;patch=1 \
           file://0001-Removed-resolution-check-that-prevents-scaling-when.patch;patch=1 \
           file://0001-Implement-downsampling-with-debugs.patch;patch=1 \
           file://musb-rxtx.patch;patch=1 \
"

# SquashFS 4 Patches.

SRC_URI_append = " \
           file://squashfs/0006-SquashFS-Backport-SquashFS4-to-our-2.6.27-tree.patch;patch=1 \
"

# AUFS2 Patches.

SRC_URI_append = " \
           file://aufs2/0007-AUFS2-Add-latest-AUFS2-in-tree-code-for-2.6.27.patch;patch=1 \
"

S = "${WORKDIR}/git"

repository: djwillis/meta-openpandora

repo_name: djwillis/meta-openpandora


text:
@article{padula_structural_analysis_in_a_conceptual_design_framework,
author = "Sharon Padula and Jay Robinson and Llyod Eldred",
title  = "Structural Analysis In A Conceptual Design Framework",
journal= "53rd AIAA/ASME/ASCE/AHS/ASC Structures, Structural Dynamics and Materials conference, 20th AIAA/ASME/AHS Adaptive Structures Conference, 14th AIAA",
year   = 2012,
month  = 4,
}

repository: JustinClough/grasp

repo_name: JustinClough/grasp


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

package format

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 NewDomain struct {
	Domain               []byte         `protobuf:"bytes,1,opt,name=domain" json:"domain,omitempty"`
	TimeSeen             *uint32        `protobuf:"varint,2,opt,name=time_seen,json=timeSeen" json:"time_seen,omitempty"`
	Type                 *DnsDedupeType `protobuf:"varint,13,opt,name=type,enum=format.DnsDedupeType" json:"type,omitempty"`
	Count                *uint32        `protobuf:"varint,10,opt,name=count" json:"count,omitempty"`
	TimeFirst            *uint32        `protobuf:"varint,11,opt,name=time_first,json=timeFirst" json:"time_first,omitempty"`
	TimeLast             *uint32        `protobuf:"varint,12,opt,name=time_last,json=timeLast" json:"time_last,omitempty"`
	ZoneTimeFirst        *uint32        `protobuf:"varint,17,opt,name=zone_time_first,json=zoneTimeFirst" json:"zone_time_first,omitempty"`
	ZoneTimeLast         *uint32        `protobuf:"varint,18,opt,name=zone_time_last,json=zoneTimeLast" json:"zone_time_last,omitempty"`
	ResponseIp           []byte         `protobuf:"bytes,14,opt,name=response_ip,json=responseIp" json:"response_ip,omitempty"`
	Rrname               []byte         `protobuf:"bytes,3,opt,name=rrname" json:"rrname,omitempty"`
	Rrtype               *uint32        `protobuf:"varint,4,opt,name=rrtype" json:"rrtype,omitempty"`
	Rrclass              *uint32        `protobuf:"varint,5,opt,name=rrclass" json:"rrclass,omitempty"`
	Rrttl                *uint32        `protobuf:"varint,6,opt,name=rrttl" json:"rrttl,omitempty"`
	Rdata                [][]byte       `protobuf:"bytes,7,rep,name=rdata" json:"rdata,omitempty"`
	Response             []byte         `protobuf:"bytes,15,opt,name=response" json:"response,omitempty"`
	Bailiwick            []byte         `protobuf:"bytes,16,opt,name=bailiwick" json:"bailiwick,omitempty"`
	Keys                 [][]byte       `protobuf:"bytes,9,rep,name=keys" json:"keys,omitempty"`
	NewDomain            *bool          `protobuf:"varint,19,opt,name=new_domain,json=newDomain" json:"new_domain,omitempty"`
	NewRrname            *bool          `protobuf:"varint,20,opt,name=new_rrname,json=newRrname" json:"new_rrname,omitempty"`
	NewRrtype            *bool          `protobuf:"varint,21,opt,name=new_rrtype,json=newRrtype" json:"new_rrtype,omitempty"`
	NewRr                []bool         `protobuf:"varint,22,rep,name=new_rr,json=newRr" json:"new_rr,omitempty"`
	NewRrset             *bool          `protobuf:"varint,23,opt,name=new_rrset,json=newRrset" json:"new_rrset,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_NewDomain proto.InternalMessageInfo

func (m *NewDomain) GetDomain() []byte {
	if m != nil {
		return m.Domain
	}
	return nil
}

func (m *NewDomain) GetTimeSeen() uint32 {
	if m != nil && m.TimeSeen != nil {
		return *m.TimeSeen
	}
	return 0
}

func (m *NewDomain) GetType() DnsDedupeType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return DnsDedupeType_INSERTION
}

func (m *NewDomain) GetCount() uint32 {
	if m != nil && m.Count != nil {
		return *m.Count
	}
	return 0
}

func (m *NewDomain) GetTimeFirst() uint32 {
	if m != nil && m.TimeFirst != nil {
		return *m.TimeFirst
	}
	return 0
}

func (m *NewDomain) GetTimeLast() uint32 {
	if m != nil && m.TimeLast != nil {
		return *m.TimeLast
	}
	return 0
}

func (m *NewDomain) GetZoneTimeFirst() uint32 {
	if m != nil && m.ZoneTimeFirst != nil {
		return *m.ZoneTimeFirst
	}
	return 0
}

func (m *NewDomain) GetZoneTimeLast() uint32 {
	if m != nil && m.ZoneTimeLast != nil {
		return *m.ZoneTimeLast
	}
	return 0
}

func (m *NewDomain) GetResponseIp() []byte {
	if m != nil {
		return m.ResponseIp
	}
	return nil
}

func (m *NewDomain) GetRrname() []byte {
	if m != nil {
		return m.Rrname
	}
	return nil
}

func (m *NewDomain) GetRrtype() uint32 {
	if m != nil && m.Rrtype != nil {
		return *m.Rrtype
	}
	return 0
}

func (m *NewDomain) GetRrclass() uint32 {
	if m != nil && m.Rrclass != nil {
		return *m.Rrclass
	}
	return 0
}

func (m *NewDomain) GetRrttl() uint32 {
	if m != nil && m.Rrttl != nil {
		return *m.Rrttl
	}
	return 0
}

func (m *NewDomain) GetRdata() [][]byte {
	if m != nil {
		return m.Rdata
	}
	return nil
}

func (m *NewDomain) GetResponse() []byte {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *NewDomain) GetBailiwick() []byte {
	if m != nil {
		return m.Bailiwick
	}
	return nil
}

func (m *NewDomain) GetKeys() [][]byte {
	if m != nil {
		return m.Keys
	}
	return nil
}

func (m *NewDomain) GetNewDomain() bool {
	if m != nil && m.NewDomain != nil {
		return *m.NewDomain
	}
	return false
}

func (m *NewDomain) GetNewRrname() bool {
	if m != nil && m.NewRrname != nil {
		return *m.NewRrname
	}
	return false
}

func (m *NewDomain) GetNewRrtype() bool {
	if m != nil && m.NewRrtype != nil {
		return *m.NewRrtype
	}
	return false
}

func (m *NewDomain) GetNewRr() []bool {
	if m != nil {
		return m.NewRr
	}
	return nil
}

func (m *NewDomain) GetNewRrset() bool {
	if m != nil && m.NewRrset != nil {
		return *m.NewRrset
	}
	return false
}

func init() {
	proto.RegisterType((*NewDomain)(nil), "format.NewDomain")
}

func init() { proto.RegisterFile("newdomain.proto", fileDescriptor_6c8736039976de9f) }

var fileDescriptor_6c8736039976de9f = []byte{
	// 389 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x52, 0xc1, 0xae, 0x93, 0x40,
	0x14, 0x0d, 0xb6, 0xf0, 0xe0, 0x3e, 0x5a, 0x74, 0x7c, 0x7d, 0xde, 0x54, 0x8d, 0xc4, 0x18, 0x83,
	0x9b, 0x2e, 0xfc, 0x86, 0xc6, 0xc4, 0xc4, 0xb8, 0xc0, 0xee, 0xc9, 0x58, 0x6e, 0x13, 0x52, 0x18,
	0xc8, 0xcc, 0x34, 0xa4, 0xee, 0xfc, 0xf3, 0x17, 0xee, 0x00, 0xed, 0x8e, 0x73, 0xce, 0x9d, 0x73,
	0xb8, 0x67, 0x06, 0x12, 0x45, 0x7d, 0xd9, 0x36, 0xb2, 0x52, 0xbb, 0x4e, 0xb7, 0xb6, 0x15, 0xc1,
	0xa9, 0xd5, 0x8d, 0xb4, 0xdb, 0xa4, 0x54, 0xa6, 0xa4, 0xf2, 0xd2, 0x91, 0x13, 0x3e, 0xff, 0xf7,
	0x21, 0xfa, 0x4d, 0xfd, 0x9e, 0x87, 0xc5, 0x33, 0x04, 0xee, 0x18, 0x7a, 0xa9, 0x97, 0xc5, 0xf9,
	0x88, 0xc4, 0x7b, 0x88, 0x6c, 0xd5, 0x50, 0x61, 0x88, 0x14, 0xbe, 0x4a, 0xbd, 0x6c, 0x95, 0x87,
	0x03, 0xf1, 0x87, 0x48, 0x89, 0x6f, 0xb0, 0xb4, 0xd7, 0x8e, 0x70, 0x95, 0x7a, 0xd9, 0xfa, 0xfb,
	0x66, 0xe7, 0xa2, 0x76, 0x7b, 0x65, 0xf6, 0x9c, 0x74, 0xb8, 0x76, 0x94, 0xf3, 0x88, 0x78, 0x02,
	0xff, 0xd8, 0x5e, 0x94, 0x45, 0x60, 0x0f, 0x07, 0xc4, 0x47, 0x00, 0x76, 0x3f, 0x55, 0xda, 0x58,
	0x7c, 0x64, 0x89, 0xf3, 0x7e, 0x0c, 0xc4, 0x1c, 0x5e, 0x4b, 0x63, 0x31, 0xbe, 0x85, 0xff, 0x92,
	0xc6, 0x8a, 0xaf, 0x90, 0xfc, 0x6b, 0x15, 0x15, 0x77, 0x06, 0x6f, 0x78, 0x64, 0x35, 0xd0, 0x87,
	0xd9, 0xe4, 0x0b, 0xac, 0x6f, 0x73, 0xec, 0x24, 0x78, 0x2c, 0x9e, 0xc6, 0xd8, 0xed, 0x13, 0x3c,
	0x6a, 0x32, 0x5d, 0xab, 0x0c, 0x15, 0x55, 0x87, 0x6b, 0x2e, 0x01, 0x26, 0xea, 0x67, 0x37, 0x14,
	0xa4, 0xb5, 0x92, 0x0d, 0xe1, 0xc2, 0x15, 0xe4, 0x90, 0xe3, 0xb9, 0x85, 0x25, 0xdb, 0x8e, 0x48,
	0x20, 0x3c, 0x68, 0x7d, 0xac, 0xa5, 0x31, 0xe8, 0xb3, 0x30, 0xc1, 0xa1, 0x0a, 0xad, 0xad, 0xad,
	0x31, 0x70, 0x55, 0x30, 0x60, 0xb6, 0x94, 0x56, 0xe2, 0x43, 0xba, 0xc8, 0xe2, 0xdc, 0x01, 0xb1,
	0x85, 0x70, 0xfa, 0x07, 0x4c, 0x38, 0x77, 0xc6, 0xe2, 0x03, 0x44, 0x7f, 0x65, 0x55, 0x57, 0x7d,
	0x75, 0x3c, 0xe3, 0x6b, 0x16, 0x6f, 0x84, 0x10, 0xb0, 0x3c, 0xd3, 0xd5, 0x60, 0xc4, 0x76, 0xfc,
	0x3d, 0xd4, 0xad, 0xa8, 0x2f, 0xc6, 0x8b, 0x7e, 0x9b, 0x7a, 0x59, 0x98, 0x47, 0x6a, 0x7e, 0x03,
	0xa3, 0x3c, 0xae, 0xf9, 0x34, 0xcb, 0xb9, 0xdb, 0x74, 0x96, 0x79, 0xdb, 0xcd, 0x9d, 0xcc, 0x0b,
	0x6f, 0x20, 0x70, 0x32, 0x3e, 0xa7, 0x8b, 0x2c, 0xcc, 0x7d, 0x96, 0x86, 0x3b, 0x74, 0xb4, 0x21,
	0x8b, 0xef, 0xf8, 0x50, 0xc8, 0x8a, 0x21, 0xfb, 0x12, 0x00, 0x00, 0xff, 0xff, 0x46, 0x1e, 0x03,
	0xca, 0xae, 0x02, 0x00, 0x00,
}

repository: DCSO/balboa

repo_name: DCSO/balboa

gha_license_id: NOASSERTION

gha_language: C