text:
DESCRIPTION = "Linux kernel for Samsung TV's"
HOMEPAGE = "http://www.samsung.com/global/opensource/files"
LICENSE = "GPL"
DEPENDS = "binutils-cross yes-native u-boot-mkimage-selp-native"

SRC_URI = "${SAMSUNG_OS_MIRROR}/32B650.zip \
		${SAMSUNG_OS_MIRROR}/LE40B650T2P.zip \
		file://${MACHINE}-dotconfig \
		file://selp-fix_nonlinux_compile.patch;patch=1 \
"
SRC_URI_append_samygo += "file://selp-gadget.patch;patch=1 \
		file://selp-ralink-devlist.patch;patch=1;pnum=0 \
		file://selp-ralink-devlist_2.2.0.0.patch;patch=1;pnum=0 \
"

S = "${WORKDIR}/linux/linux-r011"

KERNEL_VERSION_samygo = ${PV}
KERNEL_LOCALVERSION = "_SELP-ARM"
inherit kernel

FILES_dvb-includes = "/usr/include/linux/dvb"
FILES_scsi-includes = "/usr/include/linux/scsi"

COMPATIBLE_HOST = "arm.*-linux"
COMPATIBLE_MACHINE = "T-C.*C"

export OS = "Linux"
ARCH = "arm"

do_unpack2() {
        tar -xvzf ${WORKDIR}/linux.chelsea.tgz -C ${WORKDIR}/
	tar -xvzf ${WORKDIR}/linux.cip.open.tgz -C ${WORKDIR}/ linux/linux-r011/drivers/rt73
	tar -xvzf ${WORKDIR}/linux.cip.open.tgz -C ${WORKDIR}/ linux/linux-r011/drivers/rt2870
	rm -f ${WORKDIR}/*.zip ${WORKDIR}/SELP* ${WORKDIR}/*.tgz ${WORKDIR}/*.gz || true
 	# Branding
	perl -pi -e "s/0.994/0.994 \[SamyGO\]/g" ${WORKDIR}/linux/linux-r011/drivers/rt73/Module/rtmp_main.c
        perl -pi -e "s/1.002\(1.4.0.0\)/1.002\(1.4.0.0\) \[SamyGO\]/g" ${WORKDIR}/linux/linux-r011/drivers/rt2870/os/linux/2870_main_dev.c
}

addtask unpack2 before do_patch after do_unpack

do_configure_prepend() {
	echo ${CROSS_COMPILE} > .mvl_cross_compile
	echo ${TARGET_ARCH} > .mvl_target_cpu

	./mkconfig.sh ${MACHINE_KERNEL_CONFIG_CMD_ARGS}
#	oe_runmake include/linux/version.h

#	oe_machinstall -m 0644 ${WORKDIR}/${MACHINE}-dotconfig ${S}/.config
#	oe_runmake oldconfig

        perl -pi -e "s/# (CONFIG_SMB_FS) .*/\1=m/" ${S}/.config
# CONFIG_SMB_NLS_DEFAULT is not set
        perl -pi -e "s/# (CONFIG_CIFS) .*/\1=m\nCONFIG_CIFS_EXPERIMENTAL=y/" ${S}/.config
	perl -pi -e "s/# (CONFIG_CODA_FS) .*/\1=m/" ${S}/.config

        perl -pi -e "s/# (CONFIG_USB_GADGET) .*/\1=m/" ${S}/.config
        echo '# USB Gadget Support
#
# CONFIG_USB_GADGET_DEBUG_FILES is not set
CONFIG_USB_GADGET_SELECTED=y
# CONFIG_USB_GADGET_NET2280 is not set
# CONFIG_USB_GADGET_PXA2XX is not set
# CONFIG_USB_GADGET_GOKU is not set
# CONFIG_USB_GADGET_LH7A40X is not set
# CONFIG_USB_GADGET_OMAP is not set
# CONFIG_USB_GADGET_AT91 is not set
CONFIG_USB_GADGET_DUMMY_HCD=y
CONFIG_USB_DUMMY_HCD=m
CONFIG_USB_GADGET_DUALSPEED=y
# CONFIG_USB_ZERO is not set
# CONFIG_USB_ETH is not set
# CONFIG_USB_GADGETFS is not set
CONFIG_USB_FILE_STORAGE=m
CONFIG_USB_FILE_STORAGE_TEST=y
# CONFIG_USB_G_SERIAL is not set
' >> ${S}/.config

	gcc_version=`${KERNEL_CC} -dumpversion`
                if [ "${gcc_version}" == "4.0.1" ] || [ "${gcc_version}" == "4.0.2" ]; then
                        die "tosa kernel wont work with gcc 4.0.x"
                fi
}

do_compile_append_samygo(){
	oe_runmake zImage
}

do_stage_prepend () {
	rm -f ${S}/include/asm-${TARGET_ARCH}/arch-ssdtv || true
	rm -f ${S}/include/asm-${TARGET_ARCH}/arch || true
	cp -avf ${WORKDIR}/linux/ssdtv_platform/include/asm-${TARGET_ARCH}/arch-ssdtv ${S}/include/asm-${TARGET_ARCH}/
	cp -avf ${WORKDIR}/linux/ssdtv_platform/include/asm-${TARGET_ARCH}/arch-ssdtv ${S}/include/asm/arch
}

do_stage_append () {
	install ${S}/.mvl_cross_compile ${STAGING_KERNEL_DIR}/
	install ${S}/.mvl_target_cpu ${STAGING_KERNEL_DIR}/
}

repository: metalsky/SamyGO

repo_name: metalsky/SamyGO


text:
@INPROCEEDINGS{Cardoso2013USDLTOSCA,
author = {Jorge Cardoso and Tobias Binz and Uwe Breitenb{\"u}cher and Oliver	Kopp and Frank Leymann},
title = {Cloud Computing Automation: Integrating USDL and TOSCA},
booktitle = {25th Conference on Advanced Information Systems Engineering (CAiSE	2013)},
year = {2013},
volume = {7908},
series = {LNCS},
pages = {1--16},
publisher = {Springer},
abstract = {Standardization efforts to simplify the management of cloud applications	are being conducted in isolation. The objective of this paper is	to investigate to which extend two promising specifications, USDL	and TOSCA, can be integrated to automate the lifecycle of cloud applications.	In our approach, we selected a commercial SaaS CRM platform, modeled	it using the service description language USDL, modeled its cloud	deployment using TOSCA, and constructed a prototypical platform to	integrate service selection with deployment. Our evaluation indicates	that a high level of integration is possible. We were able to fully	automatize the remote deployment of a cloud service after it was	selected by a customer in a marketplace. Architectural decisions	emerged during the construction of the platform and were related	to global service identification and access, multi-layer routing,	and dynamic binding.},
webpdf = {/Papers/CP-2013-068-CAISE-USDL-and-TOSCA.pdf}}

license: MIT

license_type: permissive

branch_name: refs/heads/master

extension: bib


text:
require recipes-images/angstrom/console-image.bb

DEPENDS += "bash perl gcc i2c-tools \
"

IMAGE_INSTALL += "bash perl gcc i2c-tools ethtool iperf	\
	net-tools nfs-utils-client portmap tcpdump	\
"

export IMAGE_BASENAME = "extended-console-image"

extension: bb


text:
package observer

import (
	"fmt"
)

type Observer interface {
	Notify(string)
}

type Publisher struct {
	ObserverList []Observer
}

func (p *Publisher) Subscribe(o Observer) {
	p.ObserverList = append(p.ObserverList, o)
}

func (p *Publisher) Unsubscribe(o Observer) {
	var index int
	for i, v := range p.ObserverList {
		if v == o {
			index = i
			break
		}
	}

	p.ObserverList = append(p.ObserverList[:index], p.ObserverList[index + 1:]...)
}

func (p *Publisher) Publish(m string) {
	fmt.Println("Got new message! Publishing...")
	for _, o := range p.ObserverList {
		o.Notify(m)
	}
	fmt.Println("Puplished!")
}

repository: shade/golang-design-patterns

repo_name: shade/golang-design-patterns

gha_license_id: MIT

extension: go


text:
@Book{knuth:84,
  author = 	 {Donald E. Knuth},
  title = 	 {The {\TeX} Book},
  publisher = 	 {Addison-Wesley},
  year = 	 {1984},
  edition = 	 {15th}
}

@InCollection{boulic:91,
  author = 	 {R. Boulic and O. Renault},
  title = 	 {3D Hierarchies for Animation},
  booktitle = 	 {New Trends in Animation and Visualization},
  publisher =    {John Wiley {\&} Sons ltd.},
  year = 	 {1991},
  editor = 	 {Nadia Magnenat-Thalmann and Daniel Thalmann}
}

@InCollection{smith:99,
  author = 	 {A. Smith and B. Jones},
  title = 	 {On the Complexity of Computing},
  booktitle = 	 {Advances in Computer Science},
  pages = 	 {555--566},
  publisher =    {Publishing Press},
  year = 	 {1999},
  editor = 	 {A. B. Smith-Jones}
}

gha_language: Python


text:
@InProceedings{suzuki10a,
  title = {Sufficient Dimension Reduction via Squared-loss Mutual Information Estimation},
  author = {Taiji Suzuki and Masashi Sugiyama},
  pages = {804--811},
  abstract = {The goal of sufficient dimension reduction in supervised learning is to find the lowdimensional subspace of input features that is sufficient for predicting output values. In this paper, we propose a novel sufficient dimension reduction method using a squaredloss variant of mutual information as a dependency measure. We utilize an analytic approximator of squared-loss mutual information based on density ratio estimation, which is shown to possess suitable convergence properties. We then develop a natural gradient algorithm for sufficient subspace search. Numerical experiments show that the proposed method compares favorably with existing dimension reduction approaches.},
  pdf = {http://jmlr.org/proceedings/papers/v9/suzuki10a/suzuki10a.pdf},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
require espeak.inc

PR = "r0"

inherit native

PACKAGES = "${PN}"
FILES_${PN} = "${layout_datadir}"

PACKAGE_ARCH = "${MACHINE_ARCH}"
TARGET_ARCH = "${MACHINE_ARCH}"

do_compile() {
        # Fixing byte order of phoneme data files
        cd "${S}/platforms/big_endian"
        sed -i '/^ *CC *=/d' Makefile
        sed -i 's/\(.*BYTE_ORDER\)/#undef BYTE_ORDER\n#define BYTE_ORDER BIG_ENDIAN\n\1/' espeak-phoneme-data.c
        oe_runmake
        ./espeak-phoneme-data "${S}/espeak-data"
        cp -f phondata phonindex phontab "${S}/espeak-data"
}

do_install() {
        install -d ${D}${layout_datadir}/espeak-data
        install -m 0644 ${S}/espeak-data/phon* ${D}${layout_datadir}/espeak-data
}

do_stage() {
        :
}

SRC_URI[md5sum] = "5c7b292d0537232868b4ac1317d76c02"
SRC_URI[sha256sum] = "77f406c345362185ec4f362bf49f61d202e01ac9b9cd5c14f803195a544ce6d3"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
package main

import (
	"fmt"
	"net"

	pb "github.com/lutece-awesome/osiris-next/codegen"
	constant "github.com/lutece-awesome/osiris-next/constant"
	osiris "github.com/lutece-awesome/osiris-next/server"
	util "github.com/lutece-awesome/osiris-next/util"
	"google.golang.org/grpc"

	log "github.com/sirupsen/logrus"
)

func main() {
	util.MakeDirectoryIfNotExists(*constant.Work)
	lis, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", *constant.Port))
	if err != nil {
		log.Error("failed to listen: %v", err)
	}
	log.Info("osiris gRPC server listen to ", *constant.Port)
	var opts []grpc.ServerOption
	grpcServer := grpc.NewServer(opts...)
	pb.RegisterOsirisServer(grpcServer, osiris.NewServer())
	grpcServer.Serve(lis)
}

repository: lutece-awesome/osiris-next

repo_name: lutece-awesome/osiris-next

branch_name: refs/heads/main


text:
@article{Yu2019Simultaneous,
 abstract = {Probabilistic graphical models provide a flexible yet parsimonious framework for modeling dependencies among nodes in networks. There is a vast literature on parameter estimation and consistent model selection for graphical models. However, in many of the applications, scientists are also interested in quantifying the uncertainty associated with the estimated parameters and selected models, which current literature has not addressed thoroughly. In this paper, we propose a novel estimator for statistical inference on edge parameters in pairwise graphical models based on generalized Hyvärinen scoring rule. Hyv̈̊inen scoring rule is especially useful in cases where the normalizing constant cannot be obtained efficiently in a closed form, which is a common problem for graphical models, including Ising models and truncated Gaussian graphical models. Our estimator allows us to perform statistical inference for general graphical models whereas the existing works mostly focus on statistical inference for Gaussian graphical models where finding normalizing constant is computationally tractable. Under mild conditions that are typically assumed in the literature for consistent estimation, we prove that our proposed estimator is $\sqrtn$-consistent and asymptotically normal, which allows us to construct confidence intervals and build hypothesis tests for edge parameters. Moreover, we show how our proposed method can be applied to test hypotheses that involve a large number of model parameters simultaneously. We illustrate validity of our estimator through extensive simulation studies on a diverse collection of data-generating processes.},
 author = {Ming Yu and Varun Gupta and Mladen Kolar},
 date = {2019-05-15},
 eprint = {http://arxiv.org/abs/1905.06261v1},
 eprintclass = {stat.ME},
 eprinttype = {arXiv},
 file = {:http\://arxiv.org/pdf/1905.06261v1:PDF},
 journal = {arXiv 1905.06261},
 keywords = {stat.ME},
 title = {Simultaneous Inference for Pairwise Graphical Models with Generalized Score Matching},
 year = {2019}
}


text:
SUMMARY = "FFmpeg nvidia headers"
HOMEPAGE = "https://git.videolan.org/git/ffmpeg/nv-codec-headers.git"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${S}/include/ffnvcodec/dynlink_cuda.h;beginline=1;endline=26;md5=bb54a418154445b0aa99e15f640eacf4"

SRC_URI = " \
    git://git.videolan.org/git/ffmpeg/nv-codec-headers.git;branch=master;protocol=https \
    file://0001-Makefile-add-clean-target.patch \
"
SRCREV = "c5e4af74850a616c42d39ed45b9b8568b71bf8bf"
S = "${WORKDIR}/git"

EXTRA_OEMAKE = "PREFIX=${prefix} DESTDIR=${D} LIBDIR=${baselib}"

do_install() {
    oe_runmake install
}

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded

gha_language: BitBake


text:
require prboom_${PV}.bb

PR = "r6"

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

SRC_URI_append = " file://prboom.png \
                   file://prboom.desktop \
		   file://prboom.sh "

do_install_append() {
        install -d ${D}${palmtopdir}/apps/Games \
        	   ${D}${palmtopdir}/pics \

	install -m 0755 ${WORKDIR}/prboom.sh ${D}${bindir}
	install -m 0644 ${WORKDIR}/prboom.png ${D}${palmtopdir}/pics/prboom.png
	install -m 0644 ${WORKDIR}/prboom.desktop ${D}${palmtopdir}/apps/Games/prboom.desktop
}

FILES_${PN}_append = " ${palmtopdir}"

SRC_URI[md5sum] = "ef0abe0aad017514857552434b5c6aaa"
SRC_URI[sha256sum] = "200d3c50b082ae46be8c014bb576b4e2d23b1704508fd528c47e3e2b3b04759e"


text:
import Layout from '@/layout'

const edituserRouter = {
  path: '/edituser',
  name: 'Edituser',
  component: Layout,
  children: [
    {
      path: '',
      name: 'Edituser',
      component: () => import('@/views/edituser/index.vue'),
      hidden: true,
      meta: { title: '编辑资料', icon: 'form' }
    }
  ]
}

export default edituserRouter

extension: js


text:
@article{bengio2012,
  author    = {Yoshua Bengio and
               Aaron C. Courville and
               Pascal Vincent},
  title     = {Unsupervised Feature Learning and Deep Learning: {A} Review and New
               Perspectives},
  journal   = {CoRR},
  volume    = {abs/1206.5538},
  year      = {2012},
  url       = {http://arxiv.org/abs/1206.5538},
  timestamp = {Wed, 10 Oct 2012 21:28:53 +0200},
  biburl    = {http://dblp.uni-trier.de/rec/bib/journals/corr/abs-1206-5538},
  bibsource = {dblp computer science bibliography, http://dblp.org}
}

@article{gatys15,
  author    = {Leon A. Gatys and
               Alexander S. Ecker and
               Matthias Bethge},
  title     = {A Neural Algorithm of Artistic Style},
  journal   = {CoRR},
  volume    = {abs/1508.06576},
  year      = {2015},
  url       = {http://arxiv.org/abs/1508.06576},
  timestamp = {Tue, 01 Sep 2015 14:42:40 +0200},
  biburl    = {http://dblp.uni-trier.de/rec/bib/journals/corr/GatysEB15a},
  bibsource = {dblp computer science bibliography, http://dblp.org},
  annotate  = {The most important article detailing the algorithm for replicating painting styles.}
}

@article{jia14,
  author    = {Yangqing Jia and
               Evan Shelhamer and
               Jeff Donahue and
               Sergey Karayev and
               Jonathan Long and
               Ross B. Girshick and
               Sergio Guadarrama and
               Trevor Darrell},
  title     = {Caffe: Convolutional Architecture for Fast Feature Embedding},
  journal   = {CoRR},
  volume    = {abs/1408.5093},
  year      = {2014},
  url       = {http://arxiv.org/abs/1408.5093},
  timestamp = {Fri, 12 Sep 2014 12:44:21 +0200},
  biburl    = {http://dblp.uni-trier.de/rec/bib/journals/corr/JiaSDKLGGD14},
  bibsource = {dblp computer science bibliography, http://dblp.org},
  annotate  = {Original paper describing the Caffe deep learning framework which we'll be using to implement our algorithm.}
}

@article{riesenhuber99,
  title={Hierarchical models of object recognition in cortex},
  author={Riesenhuber, Maximilian and Poggio, Tomaso},
  journal={Nature Neuroscience},
  volume={2},
  number={11},
  pages={1019--1025},
  year={1999},
  publisher={Nature Publishing Group}
}

@Article{lecun2015,
author={LeCun, Yann
and Bengio, Yoshua
and Hinton, Geoffrey},
title={Deep learning},
journal={Nature},
year={2015},
month={May},
day={28},
publisher={Nature Publishing Group, a division of Macmillan Publishers Limited. All Rights Reserved.},
volume={521},
number={7553},
pages={436-444},
abstract={Deep learning allows computational models that are composed of multiple processing layers to learn representations of data with multiple levels of abstraction. These methods have dramatically improved the state-of-the-art in speech recognition, visual object recognition, object detection and many other domains such as drug discovery and genomics. Deep learning discovers intricate structure in large data sets by using the backpropagation algorithm to indicate how a machine should change its internal parameters that are used to compute the representation in each layer from the representation in the previous layer. Deep convolutional nets have brought about breakthroughs in processing images, video, speech and audio, whereas recurrent nets have shone light on sequential data such as text and speech.},
note={Insight},
issn={0028-0836},
url={http://dx.doi.org/10.1038/nature14539}
}

@article{johnson08,
author={Johnson, C.R. and Hendriks, E. and Berezhnoy, I.J. and Brevdo, E. and Hughes, S.M. and Daubechies, I. and Jia Li and Postma, E. and Wang, J.Z.},
journal={Signal Processing Magazine, IEEE},
title={Image processing for artist identification},
year={2008},
volume={25},
number={4},
pages={37-48},
keywords={art;image processing;Kroller-Muller Museum;Van Gogh Museum;art historian;artist identification;brushwork analysis;image processing tool;Art;Brushes;Educational institutions;Guidelines;High-resolution imaging;Image processing;Painting;Shape;Subspace constraints;Surface topography},
doi={10.1109/MSP.2008.923513},
ISSN={1053-5888},
month={July},
annotate = {Survey of a related problem of training a classifier to identify the artist of an image.}
}

@article{karayev14,
  author    = {Sergey Karayev and
               Aaron Hertzmann and
               Holger Winnemoeller and
               Aseem Agarwala and
               Trevor Darrell},
  title     = {Recognizing Image Style},
  journal   = {CoRR},
  volume    = {abs/1311.3715},
  year      = {2013},
  url       = {http://arxiv.org/abs/1311.3715},
  timestamp = {Tue, 03 Dec 2013 15:04:22 +0100},
  biburl    = {http://dblp.uni-trier.de/rec/bib/journals/corr/KarayevHWAD13},
  bibsource = {dblp computer science bibliography, http://dblp.org},
  annotate  = {CV article detailing how neural networks can be used to identify the style rather than the content of the image.}
}

@book{gazzaniga09,
  title={Cognitive Neuroscience: The Biology of the Mind},
  author={Gazzaniga, M.S. and Ivry, R.B. and Mangun, G.R.},
  isbn={978-0393913484},
  year={2013},
  publisher={W.W. Norton},
  city={New York}
}

@misc{ufldl,
    author = {Ng, Andrew and Ngiam, Jiquan and Foo, Chuan Y. and Mai, Yifan and Suen, Caroline},
    url = {http://ufldl.stanford.edu/wiki/index.php/UFLDL\_Tutorial},
    title = {{UFLDL Tutorial}},
    year = {2010}
}

@Article{Simonyan14c,
    author       = "Simonyan, K. and Zisserman, A.",
    title        = "Very Deep Convolutional Networks for Large-Scale Image Recognition",
    journal      = "CoRR",
    volume       = "abs/1409.1556",
    year         = "2014"
}

@article{reinhard2001color,
  title={Color transfer between images},
  author={Reinhard, Erik and Ashikhmin, Michael and Gooch, Bruce and Shirley, Peter},
  journal={IEEE Computer graphics and applications},
  number={5},
  pages={34--41},
  year={2001},
  publisher={IEEE}
}

repository: athenspeterlong/neural-art

repo_name: athenspeterlong/neural-art


text:
'use strict'

var yargs = require('yargs')
module.exports = yargs

yargs.usage('Usage: $0 [options] [directories to search]')

yargs.strict() // Show usage when an unknown argument or command is used.

yargs.help('h')
yargs.alias('h', 'help')

yargs.alias('p', 'pattern')
yargs.nargs('p', 1)
yargs.describe('p', 'Patterns to search for')
yargs.default('p', '*.tap.js')
yargs.string('p')

yargs.alias('i', 'ignore')
yargs.nargs('i', 1)
yargs.describe('i', 'Patterns to ignore')
yargs.default('i', '**/node_modules/**')
yargs.string('i')

yargs.alias('j', 'jobs')
yargs.nargs('j', 1)
yargs.describe('j', 'Number of jobs to run in parallel')
yargs.default('j', 1)

yargs.alias('t', 'timeout')
yargs.nargs('t', 1)
yargs.describe(
  't',
  'Maximum duration of tests before they are considered failed in seconds.'
)
yargs.default('t', 10)

if (yargs.argv._.length) {
  module.exports.directories = yargs.argv._
} else {
  module.exports.directories = [process.cwd()]
}

license: ISC

repository: wraithan/tread

repo_name: wraithan/tread


text:
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.25.0
// 	protoc        v3.15.8
// source: eth/v1alpha1/node.proto

package eth

import (
	context "context"
	reflect "reflect"
	sync "sync"

	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	_ "github.com/prysmaticlabs/ethereumapis/eth/ext"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// This is a compile-time assertion that a sufficiently up-to-date version
// of the legacy proto package is being used.
const _ = proto.ProtoPackageIsVersion4

type PeerDirection int32

const (
	PeerDirection_UNKNOWN  PeerDirection = 0
	PeerDirection_INBOUND  PeerDirection = 1
	PeerDirection_OUTBOUND PeerDirection = 2
)

// Enum value maps for PeerDirection.
var (
	PeerDirection_name = map[int32]string{
		0: "UNKNOWN",
		1: "INBOUND",
		2: "OUTBOUND",
	}
	PeerDirection_value = map[string]int32{
		"UNKNOWN":  0,
		"INBOUND":  1,
		"OUTBOUND": 2,
	}
)

func (x PeerDirection) Enum() *PeerDirection {
	p := new(PeerDirection)
	*p = x
	return p
}

func (x PeerDirection) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PeerDirection) Descriptor() protoreflect.EnumDescriptor {
	return file_eth_v1alpha1_node_proto_enumTypes[0].Descriptor()
}

func (PeerDirection) Type() protoreflect.EnumType {
	return &file_eth_v1alpha1_node_proto_enumTypes[0]
}

func (x PeerDirection) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PeerDirection.Descriptor instead.
func (PeerDirection) EnumDescriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{0}
}

type ConnectionState int32

const (
	ConnectionState_DISCONNECTED  ConnectionState = 0
	ConnectionState_DISCONNECTING ConnectionState = 1
	ConnectionState_CONNECTED     ConnectionState = 2
	ConnectionState_CONNECTING    ConnectionState = 3
)

// Enum value maps for ConnectionState.
var (
	ConnectionState_name = map[int32]string{
		0: "DISCONNECTED",
		1: "DISCONNECTING",
		2: "CONNECTED",
		3: "CONNECTING",
	}
	ConnectionState_value = map[string]int32{
		"DISCONNECTED":  0,
		"DISCONNECTING": 1,
		"CONNECTED":     2,
		"CONNECTING":    3,
	}
)

func (x ConnectionState) Enum() *ConnectionState {
	p := new(ConnectionState)
	*p = x
	return p
}

func (x ConnectionState) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (ConnectionState) Descriptor() protoreflect.EnumDescriptor {
	return file_eth_v1alpha1_node_proto_enumTypes[1].Descriptor()
}

func (ConnectionState) Type() protoreflect.EnumType {
	return &file_eth_v1alpha1_node_proto_enumTypes[1]
}

func (x ConnectionState) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use ConnectionState.Descriptor instead.
func (ConnectionState) EnumDescriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{1}
}

type SyncStatus struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Syncing bool `protobuf:"varint,1,opt,name=syncing,proto3" json:"syncing,omitempty"`
}

func (x *SyncStatus) Reset() {
	*x = SyncStatus{}
	if protoimpl.UnsafeEnabled {
		mi := &file_eth_v1alpha1_node_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *SyncStatus) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SyncStatus) ProtoMessage() {}

func (x *SyncStatus) ProtoReflect() protoreflect.Message {
	mi := &file_eth_v1alpha1_node_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SyncStatus.ProtoReflect.Descriptor instead.
func (*SyncStatus) Descriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{0}
}

func (x *SyncStatus) GetSyncing() bool {
	if x != nil {
		return x.Syncing
	}
	return false
}

type Genesis struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	GenesisTime            *timestamp.Timestamp `protobuf:"bytes,1,opt,name=genesis_time,json=genesisTime,proto3" json:"genesis_time,omitempty"`
	DepositContractAddress []byte               `protobuf:"bytes,2,opt,name=deposit_contract_address,json=depositContractAddress,proto3" json:"deposit_contract_address,omitempty"`
	GenesisValidatorsRoot  []byte               `protobuf:"bytes,3,opt,name=genesis_validators_root,json=genesisValidatorsRoot,proto3" json:"genesis_validators_root,omitempty" ssz-size:"32"`
}

func (x *Genesis) Reset() {
	*x = Genesis{}
	if protoimpl.UnsafeEnabled {
		mi := &file_eth_v1alpha1_node_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Genesis) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Genesis) ProtoMessage() {}

func (x *Genesis) ProtoReflect() protoreflect.Message {
	mi := &file_eth_v1alpha1_node_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Genesis.ProtoReflect.Descriptor instead.
func (*Genesis) Descriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{1}
}

func (x *Genesis) GetGenesisTime() *timestamp.Timestamp {
	if x != nil {
		return x.GenesisTime
	}
	return nil
}

func (x *Genesis) GetDepositContractAddress() []byte {
	if x != nil {
		return x.DepositContractAddress
	}
	return nil
}

func (x *Genesis) GetGenesisValidatorsRoot() []byte {
	if x != nil {
		return x.GenesisValidatorsRoot
	}
	return nil
}

type Version struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Version  string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Metadata string `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
}

func (x *Version) Reset() {
	*x = Version{}
	if protoimpl.UnsafeEnabled {
		mi := &file_eth_v1alpha1_node_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Version) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Version) ProtoMessage() {}

func (x *Version) ProtoReflect() protoreflect.Message {
	mi := &file_eth_v1alpha1_node_proto_msgTypes[2]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Version.ProtoReflect.Descriptor instead.
func (*Version) Descriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{2}
}

func (x *Version) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

func (x *Version) GetMetadata() string {
	if x != nil {
		return x.Metadata
	}
	return ""
}

type ImplementedServices struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Services []string `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"`
}

func (x *ImplementedServices) Reset() {
	*x = ImplementedServices{}
	if protoimpl.UnsafeEnabled {
		mi := &file_eth_v1alpha1_node_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *ImplementedServices) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ImplementedServices) ProtoMessage() {}

func (x *ImplementedServices) ProtoReflect() protoreflect.Message {
	mi := &file_eth_v1alpha1_node_proto_msgTypes[3]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ImplementedServices.ProtoReflect.Descriptor instead.
func (*ImplementedServices) Descriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{3}
}

func (x *ImplementedServices) GetServices() []string {
	if x != nil {
		return x.Services
	}
	return nil
}

type PeerRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	PeerId string `protobuf:"bytes,1,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
}

func (x *PeerRequest) Reset() {
	*x = PeerRequest{}
	if protoimpl.UnsafeEnabled {
		mi := &file_eth_v1alpha1_node_proto_msgTypes[4]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *PeerRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PeerRequest) ProtoMessage() {}

func (x *PeerRequest) ProtoReflect() protoreflect.Message {
	mi := &file_eth_v1alpha1_node_proto_msgTypes[4]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PeerRequest.ProtoReflect.Descriptor instead.
func (*PeerRequest) Descriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{4}
}

func (x *PeerRequest) GetPeerId() string {
	if x != nil {
		return x.PeerId
	}
	return ""
}

type Peers struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Peers []*Peer `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"`
}

func (x *Peers) Reset() {
	*x = Peers{}
	if protoimpl.UnsafeEnabled {
		mi := &file_eth_v1alpha1_node_proto_msgTypes[5]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Peers) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Peers) ProtoMessage() {}

func (x *Peers) ProtoReflect() protoreflect.Message {
	mi := &file_eth_v1alpha1_node_proto_msgTypes[5]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Peers.ProtoReflect.Descriptor instead.
func (*Peers) Descriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{5}
}

func (x *Peers) GetPeers() []*Peer {
	if x != nil {
		return x.Peers
	}
	return nil
}

type Peer struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Address         string          `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Direction       PeerDirection   `protobuf:"varint,2,opt,name=direction,proto3,enum=ethereum.eth.v1alpha1.PeerDirection" json:"direction,omitempty"`
	ConnectionState ConnectionState `protobuf:"varint,3,opt,name=connection_state,json=connectionState,proto3,enum=ethereum.eth.v1alpha1.ConnectionState" json:"connection_state,omitempty"`
	PeerId          string          `protobuf:"bytes,4,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Enr             string          `protobuf:"bytes,5,opt,name=enr,proto3" json:"enr,omitempty"`
}

func (x *Peer) Reset() {
	*x = Peer{}
	if protoimpl.UnsafeEnabled {
		mi := &file_eth_v1alpha1_node_proto_msgTypes[6]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Peer) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Peer) ProtoMessage() {}

func (x *Peer) ProtoReflect() protoreflect.Message {
	mi := &file_eth_v1alpha1_node_proto_msgTypes[6]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Peer.ProtoReflect.Descriptor instead.
func (*Peer) Descriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{6}
}

func (x *Peer) GetAddress() string {
	if x != nil {
		return x.Address
	}
	return ""
}

func (x *Peer) GetDirection() PeerDirection {
	if x != nil {
		return x.Direction
	}
	return PeerDirection_UNKNOWN
}

func (x *Peer) GetConnectionState() ConnectionState {
	if x != nil {
		return x.ConnectionState
	}
	return ConnectionState_DISCONNECTED
}

func (x *Peer) GetPeerId() string {
	if x != nil {
		return x.PeerId
	}
	return ""
}

func (x *Peer) GetEnr() string {
	if x != nil {
		return x.Enr
	}
	return ""
}

type HostData struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
	PeerId    string   `protobuf:"bytes,2,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Enr       string   `protobuf:"bytes,3,opt,name=enr,proto3" json:"enr,omitempty"`
}

func (x *HostData) Reset() {
	*x = HostData{}
	if protoimpl.UnsafeEnabled {
		mi := &file_eth_v1alpha1_node_proto_msgTypes[7]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *HostData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*HostData) ProtoMessage() {}

func (x *HostData) ProtoReflect() protoreflect.Message {
	mi := &file_eth_v1alpha1_node_proto_msgTypes[7]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use HostData.ProtoReflect.Descriptor instead.
func (*HostData) Descriptor() ([]byte, []int) {
	return file_eth_v1alpha1_node_proto_rawDescGZIP(), []int{7}
}

func (x *HostData) GetAddresses() []string {
	if x != nil {
		return x.Addresses
	}
	return nil
}

func (x *HostData) GetPeerId() string {
	if x != nil {
		return x.PeerId
	}
	return ""
}

func (x *HostData) GetEnr() string {
	if x != nil {
		return x.Enr
	}
	return ""
}

var File_eth_v1alpha1_node_proto protoreflect.FileDescriptor

var file_eth_v1alpha1_node_proto_rawDesc = []byte{
	0x0a, 0x1d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c,
	0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
	0x15, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31,
	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61,
	0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70,
	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
	0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x1a, 0x1b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x65, 0x78,
	0x74, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22,
	0x26, 0x0a, 0x0a, 0x53, 0x79, 0x6e, 0x63, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a,
	0x07, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07,
	0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x22, 0xc2, 0x01, 0x0a, 0x07, 0x47, 0x65, 0x6e, 0x65,
	0x73, 0x69, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x74,
	0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65,
	0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x54, 0x69,
	0x6d, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f, 0x63, 0x6f,
	0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x0c, 0x52, 0x16, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6e,
	0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3e, 0x0a, 0x17,
	0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
	0x72, 0x73, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a,
	0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x15, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x56, 0x61,
	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3f, 0x0a, 0x07,
	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69,
	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
	0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x31, 0x0a,
	0x13, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76,
	0x69, 0x63, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73,
	0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73,
	0x22, 0x26, 0x0a, 0x0b, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
	0x17, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
	0x52, 0x06, 0x70, 0x65, 0x65, 0x72, 0x49, 0x64, 0x22, 0x3a, 0x0a, 0x05, 0x50, 0x65, 0x65, 0x72,
	0x73, 0x12, 0x31, 0x0a, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
	0x32, 0x1b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x05, 0x70,
	0x65, 0x65, 0x72, 0x73, 0x22, 0xe2, 0x01, 0x0a, 0x04, 0x50, 0x65, 0x65, 0x72, 0x12, 0x18, 0x0a,
	0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x42, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63,
	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x65, 0x74, 0x68,
	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
	0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
	0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x51, 0x0a, 0x10, 0x63,
	0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18,
	0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
	0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f,
	0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0f, 0x63,
	0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x17,
	0x0a, 0x07, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
	0x06, 0x70, 0x65, 0x65, 0x72, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x72, 0x18, 0x05,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x72, 0x22, 0x53, 0x0a, 0x08, 0x48, 0x6f, 0x73,
	0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
	0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
	0x73, 0x65, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03,
	0x65, 0x6e, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x72, 0x2a, 0x37,
	0x0a, 0x0d, 0x50, 0x65, 0x65, 0x72, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12,
	0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07,
	0x49, 0x4e, 0x42, 0x4f, 0x55, 0x4e, 0x44, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x4f, 0x55, 0x54,
	0x42, 0x4f, 0x55, 0x4e, 0x44, 0x10, 0x02, 0x2a, 0x55, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x6e, 0x65,
	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x44, 0x49,
	0x53, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d,
	0x44, 0x49, 0x53, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12,
	0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x02, 0x12, 0x0e,
	0x0a, 0x0a, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x32, 0x85,
	0x06, 0x0a, 0x04, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x6e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x53, 0x79,
	0x6e, 0x63, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79,
	0x1a, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x53, 0x74, 0x61,
	0x74, 0x75, 0x73, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a, 0x2f, 0x65, 0x74,
	0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f,
	0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x12, 0x68, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x47, 0x65,
	0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1e, 0x2e,
	0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61,
	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x22, 0x22, 0x82,
	0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c,
	0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69,
	0x73, 0x12, 0x68, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12,
	0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
	0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65,
	0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12,
	0x1a, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e,
	0x6f, 0x64, 0x65, 0x2f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x82, 0x01, 0x0a, 0x17,
	0x4c, 0x69, 0x73, 0x74, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x53,
	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a,
	0x2a, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76,
	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e,
	0x74, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x22, 0x23, 0x82, 0xd3, 0xe4,
	0x93, 0x02, 0x1d, 0x12, 0x1b, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
	0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73,
	0x12, 0x62, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x12, 0x16, 0x2e, 0x67, 0x6f,
	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d,
	0x70, 0x74, 0x79, 0x1a, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
	0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x48, 0x6f, 0x73, 0x74,
	0x44, 0x61, 0x74, 0x61, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x65,
	0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65,
	0x2f, 0x70, 0x32, 0x70, 0x12, 0x6b, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x12,
	0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76,
	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75,
	0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
	0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72,
	0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76,
	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x70, 0x65, 0x65,
	0x72, 0x12, 0x63, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x16,
	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
	0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1c, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
	0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50,
	0x65, 0x65, 0x72, 0x73, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x65,
	0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65,
	0x2f, 0x70, 0x65, 0x65, 0x72, 0x73, 0x42, 0x8f, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65,
	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c,
	0x70, 0x68, 0x61, 0x31, 0x42, 0x09, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50,
	0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72,
	0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73,
	0x6d, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c,
	0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72,
	0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
	0xca, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c,
	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_eth_v1alpha1_node_proto_rawDescOnce sync.Once
	file_eth_v1alpha1_node_proto_rawDescData = file_eth_v1alpha1_node_proto_rawDesc
)

func file_eth_v1alpha1_node_proto_rawDescGZIP() []byte {
	file_eth_v1alpha1_node_proto_rawDescOnce.Do(func() {
		file_eth_v1alpha1_node_proto_rawDescData = protoimpl.X.CompressGZIP(file_eth_v1alpha1_node_proto_rawDescData)
	})
	return file_eth_v1alpha1_node_proto_rawDescData
}

var file_eth_v1alpha1_node_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_eth_v1alpha1_node_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
var file_eth_v1alpha1_node_proto_goTypes = []interface{}{
	(PeerDirection)(0),          // 0: ethereum.eth.v1alpha1.PeerDirection
	(ConnectionState)(0),        // 1: ethereum.eth.v1alpha1.ConnectionState
	(*SyncStatus)(nil),          // 2: ethereum.eth.v1alpha1.SyncStatus
	(*Genesis)(nil),             // 3: ethereum.eth.v1alpha1.Genesis
	(*Version)(nil),             // 4: ethereum.eth.v1alpha1.Version
	(*ImplementedServices)(nil), // 5: ethereum.eth.v1alpha1.ImplementedServices
	(*PeerRequest)(nil),         // 6: ethereum.eth.v1alpha1.PeerRequest
	(*Peers)(nil),               // 7: ethereum.eth.v1alpha1.Peers
	(*Peer)(nil),                // 8: ethereum.eth.v1alpha1.Peer
	(*HostData)(nil),            // 9: ethereum.eth.v1alpha1.HostData
	(*timestamp.Timestamp)(nil), // 10: google.protobuf.Timestamp
	(*empty.Empty)(nil),         // 11: google.protobuf.Empty
}
var file_eth_v1alpha1_node_proto_depIdxs = []int32{
	10, // 0: ethereum.eth.v1alpha1.Genesis.genesis_time:type_name -> google.protobuf.Timestamp
	8,  // 1: ethereum.eth.v1alpha1.Peers.peers:type_name -> ethereum.eth.v1alpha1.Peer
	0,  // 2: ethereum.eth.v1alpha1.Peer.direction:type_name -> ethereum.eth.v1alpha1.PeerDirection
	1,  // 3: ethereum.eth.v1alpha1.Peer.connection_state:type_name -> ethereum.eth.v1alpha1.ConnectionState
	11, // 4: ethereum.eth.v1alpha1.Node.GetSyncStatus:input_type -> google.protobuf.Empty
	11, // 5: ethereum.eth.v1alpha1.Node.GetGenesis:input_type -> google.protobuf.Empty
	11, // 6: ethereum.eth.v1alpha1.Node.GetVersion:input_type -> google.protobuf.Empty
	11, // 7: ethereum.eth.v1alpha1.Node.ListImplementedServices:input_type -> google.protobuf.Empty
	11, // 8: ethereum.eth.v1alpha1.Node.GetHost:input_type -> google.protobuf.Empty
	6,  // 9: ethereum.eth.v1alpha1.Node.GetPeer:input_type -> ethereum.eth.v1alpha1.PeerRequest
	11, // 10: ethereum.eth.v1alpha1.Node.ListPeers:input_type -> google.protobuf.Empty
	2,  // 11: ethereum.eth.v1alpha1.Node.GetSyncStatus:output_type -> ethereum.eth.v1alpha1.SyncStatus
	3,  // 12: ethereum.eth.v1alpha1.Node.GetGenesis:output_type -> ethereum.eth.v1alpha1.Genesis
	4,  // 13: ethereum.eth.v1alpha1.Node.GetVersion:output_type -> ethereum.eth.v1alpha1.Version
	5,  // 14: ethereum.eth.v1alpha1.Node.ListImplementedServices:output_type -> ethereum.eth.v1alpha1.ImplementedServices
	9,  // 15: ethereum.eth.v1alpha1.Node.GetHost:output_type -> ethereum.eth.v1alpha1.HostData
	8,  // 16: ethereum.eth.v1alpha1.Node.GetPeer:output_type -> ethereum.eth.v1alpha1.Peer
	7,  // 17: ethereum.eth.v1alpha1.Node.ListPeers:output_type -> ethereum.eth.v1alpha1.Peers
	11, // [11:18] is the sub-list for method output_type
	4,  // [4:11] is the sub-list for method input_type
	4,  // [4:4] is the sub-list for extension type_name
	4,  // [4:4] is the sub-list for extension extendee
	0,  // [0:4] is the sub-list for field type_name
}

func init() { file_eth_v1alpha1_node_proto_init() }
func file_eth_v1alpha1_node_proto_init() {
	if File_eth_v1alpha1_node_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_eth_v1alpha1_node_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*SyncStatus); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_eth_v1alpha1_node_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Genesis); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_eth_v1alpha1_node_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Version); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_eth_v1alpha1_node_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ImplementedServices); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_eth_v1alpha1_node_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*PeerRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_eth_v1alpha1_node_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Peers); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_eth_v1alpha1_node_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Peer); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_eth_v1alpha1_node_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*HostData); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_eth_v1alpha1_node_proto_rawDesc,
			NumEnums:      2,
			NumMessages:   8,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_eth_v1alpha1_node_proto_goTypes,
		DependencyIndexes: file_eth_v1alpha1_node_proto_depIdxs,
		EnumInfos:         file_eth_v1alpha1_node_proto_enumTypes,
		MessageInfos:      file_eth_v1alpha1_node_proto_msgTypes,
	}.Build()
	File_eth_v1alpha1_node_proto = out.File
	file_eth_v1alpha1_node_proto_rawDesc = nil
	file_eth_v1alpha1_node_proto_goTypes = nil
	file_eth_v1alpha1_node_proto_depIdxs = nil
}

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

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

// NodeClient is the client API for Node service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NodeClient interface {
	GetSyncStatus(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*SyncStatus, error)
	GetGenesis(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Genesis, error)
	GetVersion(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Version, error)
	ListImplementedServices(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ImplementedServices, error)
	GetHost(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*HostData, error)
	GetPeer(ctx context.Context, in *PeerRequest, opts ...grpc.CallOption) (*Peer, error)
	ListPeers(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Peers, error)
}

type nodeClient struct {
	cc grpc.ClientConnInterface
}

func NewNodeClient(cc grpc.ClientConnInterface) NodeClient {
	return &nodeClient{cc}
}

func (c *nodeClient) GetSyncStatus(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*SyncStatus, error) {
	out := new(SyncStatus)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.Node/GetSyncStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeClient) GetGenesis(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Genesis, error) {
	out := new(Genesis)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.Node/GetGenesis", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeClient) GetVersion(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Version, error) {
	out := new(Version)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.Node/GetVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeClient) ListImplementedServices(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ImplementedServices, error) {
	out := new(ImplementedServices)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.Node/ListImplementedServices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeClient) GetHost(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*HostData, error) {
	out := new(HostData)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.Node/GetHost", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeClient) GetPeer(ctx context.Context, in *PeerRequest, opts ...grpc.CallOption) (*Peer, error) {
	out := new(Peer)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.Node/GetPeer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeClient) ListPeers(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Peers, error) {
	out := new(Peers)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.Node/ListPeers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NodeServer is the server API for Node service.
type NodeServer interface {
	GetSyncStatus(context.Context, *empty.Empty) (*SyncStatus, error)
	GetGenesis(context.Context, *empty.Empty) (*Genesis, error)
	GetVersion(context.Context, *empty.Empty) (*Version, error)
	ListImplementedServices(context.Context, *empty.Empty) (*ImplementedServices, error)
	GetHost(context.Context, *empty.Empty) (*HostData, error)
	GetPeer(context.Context, *PeerRequest) (*Peer, error)
	ListPeers(context.Context, *empty.Empty) (*Peers, error)
}

// UnimplementedNodeServer can be embedded to have forward compatible implementations.
type UnimplementedNodeServer struct {
}

func (*UnimplementedNodeServer) GetSyncStatus(context.Context, *empty.Empty) (*SyncStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSyncStatus not implemented")
}
func (*UnimplementedNodeServer) GetGenesis(context.Context, *empty.Empty) (*Genesis, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetGenesis not implemented")
}
func (*UnimplementedNodeServer) GetVersion(context.Context, *empty.Empty) (*Version, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVersion not implemented")
}
func (*UnimplementedNodeServer) ListImplementedServices(context.Context, *empty.Empty) (*ImplementedServices, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListImplementedServices not implemented")
}
func (*UnimplementedNodeServer) GetHost(context.Context, *empty.Empty) (*HostData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHost not implemented")
}
func (*UnimplementedNodeServer) GetPeer(context.Context, *PeerRequest) (*Peer, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPeer not implemented")
}
func (*UnimplementedNodeServer) ListPeers(context.Context, *empty.Empty) (*Peers, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPeers not implemented")
}

func RegisterNodeServer(s *grpc.Server, srv NodeServer) {
	s.RegisterService(&_Node_serviceDesc, srv)
}

func _Node_GetSyncStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeServer).GetSyncStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.Node/GetSyncStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeServer).GetSyncStatus(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Node_GetGenesis_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeServer).GetGenesis(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.Node/GetGenesis",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeServer).GetGenesis(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Node_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeServer).GetVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.Node/GetVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeServer).GetVersion(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Node_ListImplementedServices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeServer).ListImplementedServices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.Node/ListImplementedServices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeServer).ListImplementedServices(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Node_GetHost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeServer).GetHost(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.Node/GetHost",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeServer).GetHost(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Node_GetPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeServer).GetPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.Node/GetPeer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeServer).GetPeer(ctx, req.(*PeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Node_ListPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeServer).ListPeers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.Node/ListPeers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeServer).ListPeers(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _Node_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.eth.v1alpha1.Node",
	HandlerType: (*NodeServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetSyncStatus",
			Handler:    _Node_GetSyncStatus_Handler,
		},
		{
			MethodName: "GetGenesis",
			Handler:    _Node_GetGenesis_Handler,
		},
		{
			MethodName: "GetVersion",
			Handler:    _Node_GetVersion_Handler,
		},
		{
			MethodName: "ListImplementedServices",
			Handler:    _Node_ListImplementedServices_Handler,
		},
		{
			MethodName: "GetHost",
			Handler:    _Node_GetHost_Handler,
		},
		{
			MethodName: "GetPeer",
			Handler:    _Node_GetPeer_Handler,
		},
		{
			MethodName: "ListPeers",
			Handler:    _Node_ListPeers_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "eth/v1alpha1/node.proto",
}

repository: prysmaticlabs/ethereumapis

repo_name: prysmaticlabs/ethereumapis

gha_language: Starlark


text:
DESCRIPTION = "Entice is the E17 picture viewer"
SECTION = "e/apps"
# can also depend on GIMP for editing
DEPENDS = "edb evas-x11 ecore-x11 edje epsilon esmart-x11"
LICENSE = "MIT"
HOMEPAGE = "http://www.enlightenment.org"
MAINTAINER = "Justin Patrin <papercrane@reversefold.com>"
PR = "r1"

SRC_URI = "cvs://anonymous@thinktux.net/root;module=e17/apps/entice;date=${PV}"
S = "${WORKDIR}/entice"

inherit autotools

EXTRA_OECONF = "--with-edje-cc=${STAGING_BINDIR}/edje_cc"

FILES_${PN} = "${bindir}/* ${libdir}/* ${datadir} ${sysconfdir} ${sbindir}"

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux


text:
@phdthesis{DBLP:phd/dnb/Karuppayah16,
 author = {Shankar Karuppayah},
 bibsource = {dblp computer science bibliography, https://dblp.org},
 biburl = {https://dblp.org/rec/phd/dnb/Karuppayah16.bib},
 school = {Darmstadt University of Technology, Germany},
 timestamp = {Wed, 12 Feb 2020 00:00:00 +0100},
 title = {Advanced monitoring in P2P botnets},
 url = {http://tuprints.ulb.tu-darmstadt.de/5523/},
 year = {2016}
}

repository: kshankar/academic-shankar

repo_name: kshankar/academic-shankar


text:
// Copyright © 2016 NAME HERE <EMAIL ADDRESS>
//
// 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 cmd

import (
	"fmt"
	"time"

	"github.com/spf13/cobra"
)

const (
	unixtimeResTmpl = "%s -> %d\n"
)

var (
	fromFormatStr string
)

// tounixCmd represents the tounix command
var tounixCmd = &cobra.Command{
	Use:   "tounix",
	Short: "Tounix convets time string to unixtime seconds from a given format",
	Run: func(cmd *cobra.Command, args []string) {
		layout := layoutMap[fromFormatStr]
		now := time.Now()
		for i := range args {
			if args[i] == "now" {
				fmt.Printf(unixtimeResTmpl, now.Format(layout), now.Unix())
				continue
			}

			t, _ := time.Parse(layout, args[i])
			fmt.Printf(unixtimeResTmpl, args[i], t.Unix())
		}
	},
}

func init() {
	RootCmd.AddCommand(tounixCmd)

	tounixCmd.Flags().StringVarP(&fromFormatStr, "format", "f", "", "Time expression layout format")
}


text:
@article{ISI:000271370200007,
 author = {Cerbino, Roberto and Vailati, Alberto},
 doi = {10.1016/j.cocis.2009.07.003},
 eissn = {1879-0399},
 issn = {1359-0294},
 journal = {CURRENT OPINION IN COLLOID & INTERFACE SCIENCE},
 month = {DEC},
 number = {6},
 orcid-numbers = {Vailati, Alberto/0000-0002-3119-6021
Cerbino, Roberto/0000-0003-0434-7741},
 pages = {416-425},
 researcherid-numbers = {Vailati, Alberto/B-2299-2009
Cerbino, Roberto/A-2286-2008},
 times-cited = {40},
 title = {Near-field scattering techniques: Novel instrumentation and results from
time and spatially resolved investigations of soft matter systems},
 unique-id = {ISI:000271370200007},
 volume = {14},
 year = {2009}
}

repository: rcerbino/starter-academic

repo_name: rcerbino/starter-academic


text:
@proceedings{ws-2013-statistical-parsing,
    title = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    editor = "Goldberg, Yoav  and
      Marton, Yuval  and
      Rehbein, Ines  and
      Versley, Yannick",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4900",
}
@inproceedings{lynn-etal-2013-working,
    title = "Working with a small dataset - semi-supervised dependency parsing for {I}rish",
    author = "Lynn, Teresa  and
      Foster, Jennifer  and
      Dras, Mark",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4901",
    pages = "1--11",
}
@inproceedings{kapociute-dzikiene-etal-2013-lithuanian,
    title = "{L}ithuanian Dependency Parsing with Rich Morphological Features",
    author = "Kapo{\v{c}}i{\=u}t{\.e}-Dzikien{\.e}, Jurgita  and
      Nivre, Joakim  and
      Krupavi{\v{c}}ius, Algis",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4902",
    pages = "12--21",
}
@inproceedings{agic-etal-2013-parsing,
    title = "Parsing {C}roatian and {S}erbian by Using {C}roatian Dependency Treebanks",
    author = "Agi{\'c}, {\v{Z}}eljko  and
      Merkler, Danijela  and
      Berovi{\'c}, Da{\v{s}}a",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4903",
    pages = "22--33",
}
@inproceedings{tratz-2013-cross,
    title = "A Cross-Task Flexible Transition Model for {A}rabic Tokenization, Affix Detection, Affix Labeling, {POS} Tagging, and Dependency Parsing",
    author = "Tratz, Stephen",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4904",
    pages = "34--45",
}
@inproceedings{constant-etal-2013-ligm,
    title = "The {LIGM}-{A}lpage architecture for the {SPMRL} 2013 Shared Task: Multiword Expression Analysis and Dependency Parsing",
    author = "Constant, Matthieu  and
      Candito, Marie  and
      Seddah, Djam{\'e}",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4905",
    pages = "46--52",
}
@inproceedings{de-la-clergerie-2013-exploring,
    title = "Exploring beam-based shift-reduce dependency parsing with {D}y{AL}og: Results from the {SPMRL} 2013 shared task",
    author = "de la Clergerie, {\'E}ric",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4906",
    pages = "53--62",
}
@inproceedings{ballesteros-2013-effective,
    title = "Effective Morphological Feature Selection with {M}alt{O}ptimizer at the {SPMRL} 2013 Shared Task",
    author = "Ballesteros, Miguel",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4907",
    pages = "63--70",
}
@inproceedings{goenaga-etal-2013-exploiting,
    title = "Exploiting the Contribution of Morphological Information to Parsing: the {BASQUE} {TEAM} system in the {SPRML}{`}2013 Shared Task",
    author = "Goenaga, Iakes  and
      Gojenola, Koldo  and
      Ezeiza, Nerea",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4908",
    pages = "71--77",
}
@inproceedings{cirik-sensoy-2013-ai,
    title = "The {AI}-{KU} System at the {SPMRL} 2013 Shared Task : Unsupervised Features for Dependency Parsing",
    author = "Cirik, Volkan  and
      Sensoy, Husnu",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4909",
    pages = "78--85",
}
@inproceedings{marton-etal-2013-spmrl13,
    title = "{SPMRL}{`}13 Shared Task System: The {CADIM} {A}rabic Dependency Parser",
    author = "Marton, Yuval  and
      Habash, Nizar  and
      Rambow, Owen  and
      Alkhulani, Sarah",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4910",
    pages = "86--90",
}
@inproceedings{kukkadapu-mannem-2013-statistical,
    title = "A Statistical Approach to Prediction of Empty Categories in {H}indi Dependency Treebank",
    author = "Kukkadapu, Puneeth  and
      Mannem, Prashanth",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4911",
    pages = "91--96",
}
@inproceedings{khallash-etal-2013-empirical,
    title = "An Empirical Study on the Effect of Morphological and Lexical Features in {P}ersian Dependency Parsing",
    author = "Khallash, Mojtaba  and
      Hadian, Ali  and
      Minaei-Bidgoli, Behrouz",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4912",
    pages = "97--107",
}
@inproceedings{tanaka-nagata-2013-constructing,
    title = "Constructing a Practical Constituent Parser from a {J}apanese Treebank with Function Labels",
    author = "Tanaka, Takaaki  and
      Nagata, Masaaki",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4913",
    pages = "108--118",
}
@inproceedings{malladi-mannem-2013-context,
    title = "Context Based Statistical Morphological Analyzer and its Effect on {H}indi Dependency Parsing",
    author = "Malladi, Deepak Kumar  and
      Mannem, Prashanth",
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4914",
    pages = "119--128",
}
@inproceedings{sulubacak-eryigit-2013-representation,
    title = "Representation of Morphosyntactic Units and Coordination Structures in the {T}urkish Dependency Treebank",
    author = {Sulubacak, Umut  and
      Eryi{\u{g}}it, G{\"u}l{\c{s}}en},
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4915",
    pages = "129--134",
}
@inproceedings{bjorkelund-etal-2013-ranking,
    title = "(Re)ranking Meets Morphosyntax: State-of-the-art Results from the {SPMRL} 2013 Shared Task",
    author = {Bj{\"o}rkelund, Anders  and
      {\c{C}}etino{\u{g}}lu, {\"O}zlem  and
      Farkas, Rich{\'a}rd  and
      Mueller, Thomas  and
      Seeker, Wolfgang},
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4916",
    pages = "135--145",
}
@inproceedings{seddah-etal-2013-overview,
    title = "Overview of the {SPMRL} 2013 Shared Task: A Cross-Framework Evaluation of Parsing Morphologically Rich Languages",
    author = {Seddah, Djam{\'e}  and
      Tsarfaty, Reut  and
      K{\"u}bler, Sandra  and
      Candito, Marie  and
      Choi, Jinho D.  and
      Farkas, Rich{\'a}rd  and
      Foster, Jennifer  and
      Goenaga, Iakes  and
      Gojenola Galletebeitia, Koldo  and
      Goldberg, Yoav  and
      Green, Spence  and
      Habash, Nizar  and
      Kuhlmann, Marco  and
      Maier, Wolfgang  and
      Nivre, Joakim  and
      Przepi{\'o}rkowski, Adam  and
      Roth, Ryan  and
      Seeker, Wolfgang  and
      Versley, Yannick  and
      Vincze, Veronika  and
      Woli{\'n}ski, Marcin  and
      Wr{\'o}blewska, Alina  and
      Villemonte de la Clergerie, Eric},
    booktitle = "Proceedings of the Fourth Workshop on Statistical Parsing of Morphologically-Rich Languages",
    month = oct,
    year = "2013",
    address = "Seattle, Washington, USA",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W13-4917",
    pages = "146--182",
}

repository: emorynlp/nlprankings

repo_name: emorynlp/nlprankings

gha_license_id: NOASSERTION


text:
package models

import (
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/sqlite"
)

type Product struct {
	gorm.Model
	Code  string
	Price uint
}

var (
	db *gorm.DB
)

func init() {
	var err error
	db, err = gorm.Open("sqlite3", "./systemmonitor.db")
	if err != nil {
		panic(err)
		panic("failed to connect database")
	}
	db.AutoMigrate(&Product{})
	db.AutoMigrate(&OS{})
	db.AutoMigrate(&SYS{})
	db.AutoMigrate(&NETIF{})
	db.AutoMigrate(&NETWORK{})
	db.AutoMigrate(&PARTITION{})
	db.AutoMigrate(&THERMAL{})
}

repository: lambda-zhang/systemmonitor-web

repo_name: lambda-zhang/systemmonitor-web

gha_language: JavaScript


text:
SUMMARY = "Python interface for libsystemd"
HOMEPAGE = "https://github.com/systemd/python-systemd"
LICENSE = "LGPLv2.1+"
LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=4fbd65380cdd255951079008b364516c"

PYPI_PACKAGE = "systemd-python"
DEPENDS += "systemd (<=234)"
RDEPENDS_${PN} += "systemd"
REQUIRED_DISTRO_FEATURES = "systemd"
inherit pypi setuptools distro_features_check

SRC_URI[md5sum] = "5071ea5bcb976186e92a3f5e75df221d"
SRC_URI[sha256sum] = "fd0e44bf70eadae45aadc292cb0a7eb5b0b6372cd1b391228047d33895db83e7"

repository: nedap/meta-openembedded

repo_name: nedap/meta-openembedded


text:
@article{Ladino2013:ACC,
  author   = {Ladino, Andres and Patino, Diego},
  doi      = {10.1109/ACC.2013.6580333},
  isbn     = {0743-1619; 978-1-4799-0178-4},
  issn     = {07431619},
  journal  = {2013 American Control Conference (Acc)},
  pages    = {3254--3259},
  title    = {{On the stability of predictive controllers for linear systems with variable time delays}},
  year     = {2013}
}

repository: aladinoster/al-website

repo_name: aladinoster/al-website

gha_language: Jupyter Notebook


text:
DESCRIPTION = "N64 emu - Highly modified Mupen64Plus port for libretro"

LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://mupen64plus-core/LICENSES;md5=6bf42b6befd3315498f337409d7f83c2"

inherit libretro

DEPENDS += "bc-native"

LIBRETRO_GIT_REPO = "github.com/libretro/parallel-n64.git"

LIBRETRO_PLATFORM_append_arm32 = "-classic_armv7_a7"
LIBRETRO_PLATFORM_append_arm64 = "-armv8"
LIBRETRO_PLATFORM_append_opengles = "-gles"

LIBRETRO_EXTRA_MAKEFLAGS_armarch = "USE_SSE2NEON=1"

repository: hansenlabs/meta-retro

repo_name: hansenlabs/meta-retro


text:
// 大厅发给子游戏服的消息处理

package hall

import (
	"game_server/easygo"
	"game_server/easygo/base"
	"game_server/pb/server_server"
	"game_server/pb/share_message"
	"reflect"

	"github.com/astaxie/beego/logs"
)

//===================================================================

type ServiceForSquare struct {
	Service reflect.Value
}

//分发消息
func (self *ServiceForSquare) RpcServerReport(common *base.Common, reqMsg *share_message.ServerInfo) easygo.IMessage {
	logs.Info("RpcServerReport:", reqMsg)
	//ep.SetServerId(reqMsg.GetSid())
	//SquareEpMgr.Store(reqMsg.GetSid(), ep)
	PServerInfoMgr.AddServerInfo(reqMsg)
	//TODO:对在线的玩家重新分配连接
	//endpoints := ClientEpMgr.GetEndpoints()
	//for _, p := range endpoints {
	//	player := p.GetPlayer()
	//	if player != nil {
	//		srv := PServerInfoMgr.GetIdelServer(for_game.SERVER_TYPE_SHOP)
	//		if srv != nil {
	//			player.SetShopServerId(srv.GetSid())
	//		}
	//	}
	//}
	return nil
}

//心跳
func (self *ServiceForSquare) RpcHeartBeat(common *base.Common, reqMsg *base.Empty) easygo.IMessage {
	//logs.Info("RpcHeartBeat ")
	return nil
}

// 接受广场下发ep给前端  RpcSquare2HallClient
func (self *ServiceForSquare) RpcSquare2HallClient(common *base.Common, reqMsg *share_message.MsgToClient) easygo.IMessage {
	logs.Info("=====广场接受大厅的下发 RpcSquare2HallClient====,", reqMsg)
	for _, playerId := range reqMsg.GetPlayerIds() {
		ep := ClientEpMp.LoadEndpoint(playerId)
		if ep != nil {
			msg := easygo.NewMessage(reqMsg.GetMsgName())
			err := msg.Unmarshal(reqMsg.GetMsg())
			easygo.PanicError(err)
			_, err1 := ep.CallRpcMethod(reqMsg.GetRpcName(), msg)
			easygo.PanicError(err1)
		} else {
			logs.Info("--------------->玩家不在线了,pid: %d,reqMsg: %+v", playerId, reqMsg)
		}
	}

	return nil
}

// 推送话题动态置顶/取消置顶信息
func (self *WebHttpForServer) RpcTopicDynamicTopStatus(common *base.Common, reqMsg *server_server.TopicDynamicTopLittleHelper) easygo.IMessage {
	logs.Info("==========大厅收到了话题小助手通知请求RpcTopicDynamicTopStatus: %v", reqMsg)
	pid := reqMsg.GetPlayerId()
	if pid == 0 {
		logs.Error("推送失败,请求参数为reqMsg: %v ", reqMsg)
		return easygo.NewFailMsg("推送失败")
	}
	// 小助手通知
	NoticeAssistant(pid, 1, reqMsg.GetTitle(), reqMsg.GetContent())
	return nil
}