text:
if(NOT WITH_ROCM)
    return()
endif()

# Now we don't support ROCm on windows
if(WIN32)
    return()
endif()

set(MIOPEN_ROOT ${ROCM_PATH}/miopen CACHE PATH "MIOPEN ROOT")

find_path(MIOPEN_INCLUDE_DIR "miopen/miopen.h"
    PATHS ${MIOPEN_ROOT} ${MIOPEN_ROOT}/include ${MIOPEN_ROOT}/local/include
          $ENV{MIOPEN_ROOT} $ENV{MIOPEN_ROOT}/include $ENV{MIOPEN_ROOT}/local/include
          NO_DEFAULT_PATH
)

find_library(MIOPEN_LIBRARY NAMES "libMIOpen.so"
    PATHS ${MIOPEN_ROOT} ${MIOPEN_ROOT}/lib ${MIOPEN_ROOT}/lib64 ${__libpath_hist}
          $ENV{MIOPEN_ROOT} $ENV{MIOPEN_ROOT}/lib $ENV{MIOPEN_ROOT}/lib64
          NO_DEFAULT_PATH
    DOC "Path to MIOpen library.")

if(MIOPEN_INCLUDE_DIR AND MIOPEN_LIBRARY)
    set(MIOPEN_FOUND ON)
else()
    set(MIOPEN_FOUND OFF)
endif()

macro(find_miopen_version miopen_header_file)
    file(READ ${miopen_header_file} MIOPEN_VERSION_FILE_CONTENTS)
    get_filename_component(MIOPEN_LIB_PATH ${MIOPEN_LIBRARY} DIRECTORY)

    string(REGEX MATCH "define MIOPEN_VERSION_MAJOR +([0-9]+)" MIOPEN_MAJOR_VERSION
        "${MIOPEN_VERSION_FILE_CONTENTS}")
    string(REGEX REPLACE "define MIOPEN_VERSION_MAJOR +([0-9]+)" "\\1"
        MIOPEN_MAJOR_VERSION "${MIOPEN_MAJOR_VERSION}")
    string(REGEX MATCH "define MIOPEN_VERSION_MINOR +([0-9]+)" MIOPEN_MINOR_VERSION
        "${MIOPEN_VERSION_FILE_CONTENTS}")
    string(REGEX REPLACE "define MIOPEN_VERSION_MINOR +([0-9]+)" "\\1"
        MIOPEN_MINOR_VERSION "${MIOPEN_MINOR_VERSION}")
    string(REGEX MATCH "define MIOPEN_VERSION_PATCH +([0-9]+)" MIOPEN_PATCH_VERSION
        "${MIOPEN_VERSION_FILE_CONTENTS}")
    string(REGEX REPLACE "define MIOPEN_VERSION_PATCH +([0-9]+)" "\\1"
        MIOPEN_PATCH_VERSION "${MIOPEN_PATCH_VERSION}")
    string(REGEX MATCH "define MIOPEN_VERSION_TWEAK +([0-9]+)" MIOPEN_TWEAK_VERSION
        "${MIOPEN_VERSION_FILE_CONTENTS}")
    string(REGEX REPLACE "define MIOPEN_VERSION_TWEAK +([0-9]+)" "\\1"
        MIOPEN_TWEAK_VERSION "${MIOPEN_TWEAK_VERSION}")

    if(NOT MIOPEN_MAJOR_VERSION)
        set(MIOPEN_VERSION "???")
    else()
        add_definitions("-DMIOPEN_MAJOR_VERSION=\"${MIOPEN_MAJOR_VERSION}\"")
        math(EXPR MIOPEN_VERSION
            "${MIOPEN_MAJOR_VERSION} * 1000 +
             ${MIOPEN_MINOR_VERSION} * 10 + ${MIOPEN_PATCH_VERSION}")
        message(STATUS "Current MIOpen header is ${MIOPEN_INCLUDE_DIR}/miopen/miopen.h "
          "Current MIOpen version is v${MIOPEN_MAJOR_VERSION}.${MIOPEN_MINOR_VERSION}.${MIOPEN_PATCH_VERSION}. ")
    endif()
endmacro()

if(MIOPEN_FOUND)
  find_miopen_version(${MIOPEN_INCLUDE_DIR}/miopen/version.h)
endif()

repository: sandyhouse/Paddle

repo_name: sandyhouse/Paddle

branch_name: refs/heads/develop


text:
% 2022-05-12
@article{ATLAS:2022pib,
    author = "{ATLAS Collaboration}",
    title = "{Search for heavy, long-lived, charged particles with large ionisation energy loss in $pp$ collisions at $\sqrt{s} = 13~\text{TeV}$ using the ATLAS experiment and the full Run 2 dataset}",
    eprint = "2205.06013",
    archivePrefix = "arXiv",
    primaryClass = "hep-ex",
    reportNumber = "CERN-EP-2022-029",
    month = "5",
    year = "2022",
    journal = ""
}

% 2022-03-14
@inproceedings{Albert:2022mpk,
    author = "Albert, Alexander and others",
    title = "{Strange quark as a probe for new physics in the Higgs sector}",
    booktitle = "{2022 Snowmass Summer Study}",
    eprint = "2203.07535",
    archivePrefix = "arXiv",
    primaryClass = "hep-ex",
    month = "3",
    year = "2022"
}

% 2022-03-10
@article{Simpson:2022suz,
    author = "Simpson, Nathan and Heinrich, Lukas",
    title = "{neos: End-to-End-Optimised Summary Statistics for High Energy Physics}",
    eprint = "2203.05570",
    archivePrefix = "arXiv",
    primaryClass = "physics.data-an",
    month = "3",
    year = "2022",
    journal = ""
}

% 2022-03-02
@article{EXOT-2019-23,
    author        = "{ATLAS Collaboration}",
    title         = "{Search for neutral long-lived particles in $pp$ collisions at $\sqrt{s}=13$ TeV that decay into displaced hadronic jets in the ATLAS calorimeter}",
    eprint        = "2203.01009",
    archivePrefix = "arXiv",
    primaryClass  = "hep-ex",
    reportNumber  = "CERN-EP-2022-002",
    month         = "3",
    year          = "2022",
    journal       = ""
}

% 2022-03-01
@article{EXOT-2019-24,
    author        = "{ATLAS Collaboration}",
    title         = "{Search for events with a pair of displaced vertices from long-lived neutral particles decaying into hadronic jets in the ATLAS muon spectrometer in pp collisions at $\sqrt{s}=13$ TeV}",
    eprint        = "2203.00587",
    archivePrefix = "arXiv",
    primaryClass  = "hep-ex",
    reportNumber  = "CERN-EP-2021-195",
    month         = "3",
    year          = "2022",
    journal       = ""
}

% 2021-12-29
@article{Jaffredo:2021ymt,
    author = "Jaffredo, Florentin",
    title = "{Revisiting mono-$\tau$ tails at the LHC}",
    eprint = "2112.14604",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    month = "12",
    year = "2021",
    journal = ""
}

% 2021-09-30
@booklet{ATL-PHYS-PUB-2021-038,
      author        = "{ATLAS Collaboration}",
      title         = "{Implementation of simplified likelihoods in HistFactory
                       for searches for supersymmetry}",
      institution   = "CERN",
      address       = "Geneva",
      number        = "ATL-PHYS-PUB-2021-038",
      month         = "Sep",
      year          = "2021",
      reportNumber  = "ATL-PHYS-PUB-2021-038",
      url           = "https://cds.cern.ch/record/2782654"
}

% 2021-09-17
@article{Baker:2021llj,
    author = "Baker, Michael J. and Faroughy, Darius A. and Trifinopoulos, Sokratis",
    title = "{Collider signatures of coannihilating dark matter in light of the B-physics anomalies}",
    eprint = "2109.08689",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "ZU-TH-43/21",
    doi = "10.1007/JHEP11(2021)084",
    journal = "JHEP",
    volume = "11",
    pages = "084",
    year = "2021"
}

% 2021-09-10
@article{Cranmer:2021urp,
    author = "Cranmer, Kyle and others",
    title = "{Publishing statistical models: Getting the most out of particle physics experiments}",
    eprint = "2109.04981",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    month = "9",
    year = "2021",
    journal = ""
}

% 2021-08-23
@article{Cranmer:2021oxr,
    author = "Cranmer, Kyle and Held, Alexander",
    title = "{Building and steering binned template fits with cabinetry}",
    doi = "10.1051/epjconf/202125103067",
    journal = "EPJ Web Conf.",
    volume = "251",
    pages = "03067",
    year = "2021"
}

% 2021-06-03
@article{SUSY-2019-09,
    author         = "{ATLAS Collaboration}",
    title          = "{Search for chargino--neutralino pair production in final states with three leptons and missing transverse momentum in \(\sqrt{s} = 13\,\text{TeV}\) \(pp\) collisions with the ATLAS detector}",
    journal        = "Eur. Phys. J. C",
    volume         = "81",
    year           = "2021",
    pages          = "1118",
    doi            = "10.1140/epjc/s10052-021-09749-7",
    reportNumber   = "CERN-EP-2021-059",
    eprint         = "2106.01676",
    archivePrefix  = "arXiv",
    primaryClass   = "hep-ex",
}

% 2021-05-12
@inproceedings{Dattola:2021cmw,
    author = "Belle II Collaboration",
    title = "{Search for $B^{+} \to K^{+} \nu \bar \nu$ decays with an inclusive tagging method at the Belle II experiment}",
    booktitle = "{55th Rencontres de Moriond on Electroweak Interactions and Unified Theories}",
    eprint = "2105.05754",
    archivePrefix = "arXiv",
    primaryClass = "hep-ex",
    month = "5",
    year = "2021"
}

% 2021-04-26
@article{Belle-II:2021rof,
    author = "Belle II Collaboration",
    title = "{Search for B+\textrightarrow{}K+\ensuremath{\nu}\ensuremath{\nu}\textasciimacron{} Decays Using an Inclusive Tagging Method at Belle II}",
    eprint = "2104.12624",
    archivePrefix = "arXiv",
    primaryClass = "hep-ex",
    reportNumber = "Belle II Preprint 2021-001, KEK Preprint 2020-45",
    doi = "10.1103/PhysRevLett.127.181802",
    journal = "Phys. Rev. Lett.",
    volume = "127",
    number = "18",
    pages = "181802",
    year = "2021"
}

% 2021-04-25
@article{Angelescu:2021lln,
    author = "Angelescu, Andrei and Be\v{c}irevi\'c, Damir and Faroughy, Darius A. and Jaffredo, Florentin and Sumensari, Olcyr",
    title = "{Single leptoquark solutions to the B-physics anomalies}",
    eprint = "2103.12504",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "ZU-TH 12/21",
    doi = "10.1103/PhysRevD.104.055017",
    journal = "Phys. Rev. D",
    volume = "104",
    number = "5",
    pages = "055017",
    year = "2021"
}

% 2021-03-03
@article{Feickert:2021sua,
    author = "Feickert, Matthew and Heinrich, Lukas and Stark, Giordon and Galewsky, Ben",
    title = "{Distributed statistical inference with pyhf enabled through funcX}",
    eprint = "2103.02182",
    archivePrefix = "arXiv",
    primaryClass = "cs.DC",
    doi = "10.1051/epjconf/202125102070",
    journal = "EPJ Web Conf.",
    volume = "251",
    pages = "02070",
    year = "2021"
}

% 2021-02-22
@article{Capdevilla:2021fmj,
    author = "Capdevilla, Rodolfo and Meloni, Federico and Simoniello, Rosa and Zurita, Jose",
    title = "{Hunting wino and higgsino dark matter at the muon collider with disappearing tracks}",
    eprint = "2102.11292",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "DESY-21-019, DESY 21-019, IFIC/21-03",
    doi = "10.1007/JHEP06(2021)133",
    journal = "JHEP",
    volume = "06",
    pages = "133",
    year = "2021"
}

% 2021-02-11
@article{Cirigliano:2021img,
    author = "Cirigliano, Vincenzo and Fuyuto, Kaori and Lee, Christopher and Mereghetti, Emanuele and Yan, Bin",
    title = "{Charged Lepton Flavor Violation at the EIC}",
    eprint = "2102.06176",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "LA-UR-21-20531",
    doi = "10.1007/JHEP03(2021)256",
    journal = "JHEP",
    volume = "03",
    pages = "256",
    year = "2021"
}

% 2021-01-06
@article{Fuks:2021zbm,
    author = "Fuks, Benjamin and others",
    title = "{Proceedings of the second MadAnalysis 5 workshop on LHC recasting in Korea}",
    eprint = "2101.02245",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1142/S0217732321020016",
    journal = "Mod. Phys. Lett. A",
    volume = "36",
    number = "01",
    pages = "2102001",
    year = "2021"
}

% 2020-12-22
@article{Waltenberger:2020ygp,
    author = "Waltenberger, Wolfgang and Lessa, Andr\'e and Kraml, Sabine",
    title = "{Artificial Proto-Modelling: Building Precursors of a Next Standard Model from Simplified Model Results}",
    eprint = "2012.12246",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1007/JHEP03(2021)207",
    journal = "JHEP",
    volume = "03",
    pages = "207",
    year = "2021"
}

% 2020-12-16
@article{Amoroso:2020zrz,
    author = "Amoroso, Simone and Kar, Deepak and Schott, Matthias",
    title = "{How to discover QCD Instantons at the LHC}",
    eprint = "2012.09120",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1140/epjc/s10052-021-09412-1",
    journal = "Eur. Phys. J. C",
    volume = "81",
    number = "7",
    pages = "624",
    year = "2021"
}

% 2020-12-15
@article{Alguero:2020yhu,
    author = {Alguero, Ga\"el and Heisig, Jan and Khosa, Charanjit K. and Kraml, Sabine and Kulkarni, Suchita and Lessa, Andre and Neuhuber, Philipp and Reyes-Gonz\'alez, Humberto and Waltenberger, Wolfgang and Wongel, Alicia},
    title = "{New developments in SModelS}",
    eprint = "2012.08192",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.22323/1.392.0022",
    journal = "PoS",
    volume = "TOOLS2020",
    pages = "022",
    year = "2021"
}

% 2020-11-16
@article{Feickert:2020wrx,
    author = "Feickert, Matthew and Heinrich, Lukas and Stark, Giordon",
    editor = "Doglioni, C. and Kim, D. and Stewart, G. A. and Silvestris, L. and Jackson, P. and Kamleh, W.",
    title = "{Likelihood preservation and statistical reproduction of searches for new physics}",
    reportNumber = "ATL-SOFT-PROC-2020-022",
    doi = "10.1051/epjconf/202024506017",
    journal = "EPJ Web Conf.",
    volume = "245",
    pages = "06017",
    year = "2020"
}

% 2020-09-03
@article{Alguero:2020grj,
    author = {Alguero, Ga\"el and Kraml, Sabine and Waltenberger, Wolfgang},
    title = "{A SModelS interface for pyhf likelihoods}",
    eprint = "2009.01809",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1016/j.cpc.2021.107909",
    journal = "Comput. Phys. Commun.",
    volume = "264",
    pages = "107909",
    year = "2021"
}

% 2020-08-14
@article{SUSY-2018-08,
    author         = "{ATLAS Collaboration}",
    title          = "{Search for new phenomena in events with two opposite-charge leptons, jets and missing transverse momentum in \(pp\) collisions at \(\sqrt{s} = 13\,\text{TeV}\) with the ATLAS detector}",
    journal        = "JHEP",
    volume         = "04",
    year           = "2021",
    pages          = "165",
    doi            = "10.1007/JHEP04(2021)165",
    reportNumber   = "CERN-EP-2020-243",
    eprint         = "2102.01444",
    archivePrefix  = "arXiv",
    primaryClass   = "hep-ex",
}

% 2020-05-01
@article{Khosa:2020zar,
    author = "Khosa, Charanjit K. and Kraml, Sabine and Lessa, Andre and Neuhuber, Philipp and Waltenberger, Wolfgang",
    title = "{SModelS Database Update v1.2.3}",
    eprint = "2005.00555",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.31526/lhep.2020.158",
    journal = "LHEP",
    volume = "2020",
    pages = "158",
    year = "2020"
}

@inproceedings{Brooijmans:2020yij,
    author = "Brooijmans, G. and others",
    title = "{Les Houches 2019 Physics at TeV Colliders: New Physics Working Group Report}",
    booktitle = "{11th Les Houches Workshop on Physics at TeV Colliders}: {PhysTeV Les Houches}",
    eprint = "2002.12220",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    month = "2",
    year = "2020"
}

% 2020-02-13
@article{Angelescu:2020uug,
    author = "Angelescu, Andrei and Faroughy, Darius A. and Sumensari, Olcyr",
    title = "{Lepton Flavor Violation and Dilepton Tails at the LHC}",
    eprint = "2002.05684",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "ZU-TH 02/20",
    doi = "10.1140/epjc/s10052-020-8210-5",
    journal = "Eur. Phys. J. C",
    volume = "80",
    number = "7",
    pages = "641",
    year = "2020"
}

% 2019-11-11
@article{Allanach:2019zfr,
    author = "Allanach, B. C. and Corbett, Tyler and Madigan, Maeve",
    title = "{Sensitivity of Future Hadron Colliders to Leptoquark Pair Production in the Di-Muon Di-Jets Channel}",
    eprint = "1911.04455",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1140/epjc/s10052-020-7722-3",
    journal = "Eur. Phys. J. C",
    volume = "80",
    number = "2",
    pages = "170",
    year = "2020"
}

@booklet{ATL-PHYS-PUB-2019-029,
      author        = "{ATLAS Collaboration}",
      title         = "{Reproducing searches for new physics with the ATLAS
                       experiment through publication of full statistical
                       likelihoods}",
      institution   = "CERN",
      address       = "Geneva",
      number        = "ATL-PHYS-PUB-2019-029",
      month         = "Aug",
      year          = "2019",
      reportNumber  = "ATL-PHYS-PUB-2019-029",
      url           = "https://cds.cern.ch/record/2684863",
}

@article{Heinrich:2018nip,
    author = "Heinrich, Lukas and Schulz, Holger and Turner, Jessica and Zhou, Ye-Ling",
    title = "{Constraining A$_{4}$ leptonic flavour model parameters at colliders and beyond}",
    eprint = "1810.05648",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "FERMILAB-PUB-18-548-CD-T, NSF ACI-1450310, PHY-1505463",
    doi = "10.1007/JHEP04(2019)144",
    journal = "JHEP",
    volume = "04",
    pages = "144",
    year = "2019"
}

license_type: permissive

branch_name: refs/heads/master

extension: bib


text:
package me

// GENERATED SDK for me API

// Auto renewal information
type NicAutorenewInfos struct {
	Active    bool    `json:"active,omitempty"`
	LastRenew *string `json:"lastRenew,omitempty"`
	RenewDay  int64   `json:"renewDay,omitempty"`
}

license: MIT

extension: go


text:
// Copyright (c) Tailscale Inc & AUTHORS
// SPDX-License-Identifier: BSD-3-Clause

package iosdeps

import (
	"testing"

	"tailscale.com/tstest/deptest"
)

func TestDeps(t *testing.T) {
	deptest.DepChecker{
		GOOS:   "ios",
		GOARCH: "arm64",
		BadDeps: map[string]string{
			"text/template": "linker bloat (MethodByName)",
			"html/template": "linker bloat (MethodByName)",
		},
	}.Check(t)
}

repository: tailscale/tailscale

repo_name: tailscale/tailscale

branch_name: refs/heads/main

gha_language: Go


text:
inherit core-image

DESCRIPTION = "Zuehlke Labs Custom Image"
IMAGE_INSTALL = "packagegroup-core-boot packagegroup-zuehlke-games ${CORE_IMAGE_EXTRA_INSTALL}"
IMAGE_FSTYPES = "tar.bz2 cpio squashfs"
LICENSE = "MIT"

repository: tknerr/yocto-meta-zuehlkelabs

repo_name: tknerr/yocto-meta-zuehlkelabs

extension: bb


text:
@article{Carroll1985,
  title={A note on {N} estimators for the binomial distribution},
  author={Carroll, Raymond J and Lombard, F},
  journal={Journal of the American Statistical Association},
  volume={80},
  number={390},
  pages={423--426},
  year={1985},
  publisher={Taylor \& Francis}
}
@book{Robert2007,
  title={The {B}ayesian choice: from decision-theoretic foundations to computational implementation},
  author={Robert, Christian},
  year={2007},
  publisher={Springer Science \& Business Media}
}

repository: lucasmoschen/BayesianStatisticsCourse

repo_name: lucasmoschen/BayesianStatisticsCourse

gha_license_id: MIT


text:
% Encoding: UTF-8

%%%
%
%Beim Erstellen der Bibtex-Datei wird empfohlen darauf zu achten, dass die DOI aufgeführt wird.
%
%%%

@article{Compare,
  author={CableLabs},
  title={A Comparative Introduction to 4G and 5G Authentication},
  year={2019},
  url={https://www.cablelabs.com/insights/a-comparative-introduction-to-4g-and-5g-authentication}
}

@INPROCEEDINGS{5189800,
author={A. H. {Khan} and M. A. {Qadeer} and J. A. {Ansari} and S. {Waheed}},
booktitle={2009 International Conference on Future Computer and Communication},
title={4G as a Next Generation Wireless Network},
year={2009},
volume={},
number={},
pages={334-338},
abstract={User requirements are growing faster than ever and the limitations of the current mobile communication systems have forced the researchers to come up with more advanced and efficient technologies. 4G mobile technology is the next step in this direction. 4G is the next generation of wireless networks that will totally replace 3G networks. It is supposed to provide its customers with better speed and all IP based multimedia services. 4G is all about an integrated, global network that will be able to provide a comprehensive IP solution where voice, data and streamed multimedia can be given to users on an "Anytime, Anywhere" basis. At present we have many technologies each capable of performing functions like supporting voice traffic using voice over IP (VoIP), broadband data access in mobile environment etc., but there is a great need of deploying such technologies that can integrate all these systems into a single unified system. 4G presents a solution of this problem as it is all about seamlessly integrating the terminals, networks and applications. The race to implement 4G is accelerating as well as quite challenging. The aim of this paper is to highlight the benefits, challenges in deployment and scope of 4G technologies.},
keywords={4G mobile communication;code division multiple access;frequency division multiple access;Internet telephony;packet radio networks;time division multiple access;wireless LAN;next generation wireless network;mobile communication systems;4G mobile technology;CDMA;GPRS;TDMA;FDMA;GPS;VoIP;WiFi;Next generation networking;Wireless networks;3G mobile communication;Streaming media;Computer networks;4G mobile communication;Ground penetrating radar;Time division multiple access;Frequency division multiaccess;Signal generators;4G;3G;VoIP;Wi-Fi;Wi-Max;PoC;CDMA;GPRS;TDMA;FDMA;GPS},
doi={10.1109/ICFCC.2009.108},
ISSN={},
month={4},
url={https://ieeexplore.ieee.org/abstract/document/5189800}
}

@article{itu2008requirements,
  title={Requirements related to technical performance for IMT-Advanced radio interface (s)},
  author={ITU-R},
  journal={International Telecommunications Union},
  year={2008},
  url={https://www.itu.int/pub/R-REP-M.2134-2008/en}
}

@article{kumaravel2011comparative,
  title={Comparative study of 3G and 4G in mobile technology},
  author={Kumaravel, Krishnan},
  journal={International Journal of Computer Science Issues (IJCSI)},
  volume={8},
  number={5},
  pages={256},
  year={2011},
  publisher={Citeseer},
  url={http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.642.2509&rep=rep1&type=pdf#page=266}
}

@INPROCEEDINGS{6176981,
author={M. {Winter} and S. {Kunze} and E. P. {Adeva} and B. {Mennenga} and E. {Matûs} and G. {Fettweis} and H. {Eisenreich} and G. {Ellguth} and S. {Höppner} and S. {Scholze} and R. {Schüffny} and T. {Kobori}},
booktitle={2012 IEEE International Solid-State Circuits Conference},
title={A 335Mb/s 3.9mm2 65nm CMOS flexible MIMO detection-decoding engine achieving 4G wireless data rates},
year={2012},
volume={},
number={},
pages={216-218},
abstract={In current and future wireless standards, such as WiMAX, 3GPP-LTE or LTE-Advanced, receiver terminals have to support numerous operating modes for each protocol [1], as well as sophisticated transmission techniques, especially enhanced MIMO detection and iterative forward error correction (FEC). MIMO detection and FEC belong to the most computationally complex parts of the receiver-side baseband signal processing chain. Implementations thereof must have low power consumption, but also be able to interact in a flexible and efficient way in the detection-decoding engine, while at the same time not compromising on the challenging throughput and flexibility requirements associated with 4G standards. In this paper, we present a chip implementation of a MIMO sphere detector combined with a flexible FEC engine, realizing a detection-decoding engine in silicon capable of satisfying 4G requirements with a data rate of 335Mb/s.},
keywords={4G mobile communication;CMOS integrated circuits;decoding;forward error correction;MIMO communication;CMOS flexible MIMO detection-decoding engine;4G wireless data rates;wireless standards;WiMAX;3GPP-LTE;LTE-Advanced;iterative forward error correction;receiver-side baseband signal processing chain;MIMO sphere detector;flexible FEC engine;Decoding;MIMO;Parity check codes;Throughput;Detectors;Forward error correction;Engines},
doi={10.1109/ISSCC.2012.6176981},
ISSN={},
month={2},
url={https://ieeexplore.ieee.org/abstract/document/6176981}
}

@ARTICLE{8258595,
author={S. {Parkvall} and E. {Dahlman} and A. {Furuskar} and M. {Frenne}},
journal={IEEE Communications Standards Magazine},
title={NR: The New 5G Radio Access Technology},
year={2017},
volume={1},
number={4},
pages={24-30},
abstract={This article provides an overview of the technology components and capabilities of the New Radio (NR) radio interface standard currently under development by 3GPP. NR will enable new use cases, requiring further enhanced data rates, latency, coverage, capacity, and reliability. This needs to be accomplished with improved network energy performance and the ability to exploit spectrum in very high frequency bands. Key technology components to reach these targets include flexible numerology, latency-optimized frame structure, massive MIMO, interworking between high and low frequency bands, and ultra-lean transmissions. Preliminary evaluations indicate that, with these technology components, NR can reach the 5G targets.},
keywords={3G mobile communication;cellular radio;MIMO communication;radio access networks;NR;3GPP;high frequency bands;latency-optimized frame structure;radio interface standard;data rates;5G radio access technology;network energy performance;massive MIMO;3GPP;OFDM;Bandwidth;5G mobile communication;Long Term Evolution;Resource management},
doi={10.1109/MCOMSTD.2017.1700042},
ISSN={},
month={12},
url={https://ieeexplore.ieee.org/abstract/document/8258595}
}

@article{sutton20185g,
  title={5G network architecture},
  author={Sutton, ANDY},
  journal={J. Inst. Telecommun. Professionals},
  volume={12},
  number={1},
  pages={9--15},
  year={2018}
}

@article{brown2017service,
  title={Service-Based Architecture for 5G Core Networks},
  author={Brown, GABRIEL},
  journal={A Heavy Reading white paper produced for Huawei Technologies Co. Ltd. Online verf{\"u}gbar unter: https://www. huawei. com/en/press-events/news/2017/11/HeavyReading-WhitePaper-5G-Core-Network, letzter Zugriff am},
  volume={1},
  pages={2018},
  year={2017},
  url={https://www.3g4g.co.uk/5G/5Gtech_6004_2017_11_Service-Based-Architecture-for-5G-Core-Networks_HR_Huawei.pdf}
}

@article{vulnerability,
  title={Security vulnerability in 5G-AKA draft},
  author={Dehnel-Wild, Martin and Cremers, Cas},
  journal={Department of Computer Science, University of Oxford, Tech. Rep},
  year={2018},
  url={https://www.cs.ox.ac.uk/5G-analysis/5G-AKA-draft-vulnerability.pdf}
}

@article{3gppTS33.501V15.34.1,
title={Security architecture and procedures for 5G system},
author={{3GPP TS 33.501 V15.34.1 (15.4.0)}},
year={2019},
month={3},
url={https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=3169}
}

@article{3gppTS23.003V15.7.0,
title={Numbering, addressing and identification},
author={{3GPP TS 23.003 V15.7.0}},
year={2019},
month={6},
url={https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=729}
}

@article{3gppTS33.102V15.1.0,
title={3G Security},
author={{3GPP TS 33.102 V15.1.0}},
year={2018},
month={12},
url={https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=2262}
}

@article{ietfRFC7542,
title={The Network Access Identifier},
author={{Internet Engineering Task Force (IETF)}},
year={2015},
month={5},
url={https://datatracker.ietf.org/doc/rfc7542/}
}

@article{3gppTS33.220V15.4.0,
title={Generic Authentication Architecture (GAA)},
author={{3GPP TS 33.220 V15.4.0}},
year={2018},
month={12},
url={https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=2280}
}

@article{3gppTS24.501V16.1.0,
title={Non-Access-Stratum (NAS) protocol for 5G System (5GS)},
author={{3GPP TS 24.501 V16.1.0}},
year={2019},
month={6},
url={https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=3370}
}

@article{3gppTS33.401V15.4.0,
title={3GPP System Architecture Evolution (SAE)},
author={{3GPP TS 33.401 V15.4.0}},
year={2018},
month={6},
url={https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=2296}
}

@article{3gppTS33.501V0.7.0,
title={Security architecture and procedures for 5G system},
author={{3GPP TS 33.501 V0.7.0}},
year={2018},
month={2},
url={https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=3169}
}

@Comment{jabref-meta: databaseType:biblatex;}


text:
const _ = require('lodash');
const RESOLVED_TYPES = [
  'components',
  'helpers',
  'controllers',
  'mixins',
  'models',
  'services',
  'classes',
];

module.exports = class NavigationIndexGenerator {
  generate(modules) {
    // The index is an array - the order is important for the UI
    let navIndex = [...RESOLVED_TYPES, 'modules'].map((type) => ({
      type,
      items: [],
    }));

    // Push each module into the right section
    modules.forEach((module) => {
      let moduleType = this._getModuleType(module);
      let navItem = this._getNavItemForModule(module, moduleType);

      navIndex.find(({ type }) => type === moduleType).items.push(navItem);
    });

    // Filter out empty sections, and sort non-empty section items by path
    return navIndex
      .filter((section) => section.items.length > 0)
      .map((section) => {
        section.items = _.sortBy(section.items, ['name']);

        return section;
      });
  }

  // Private

  _getModuleType(module) {
    let resolvedType = this._resolvedTypeForModule(module);

    if (!resolvedType && this._hasSingleExportOfResolvedType(module)) {
      let singleExport = this._exportsForModuleOfResolvedTypes(module)[0];
      resolvedType = singleExport.type;
    }

    return resolvedType || 'modules';
  }

  _resolvedTypeForModule(module) {
    let path = module.file.split('/');

    // By default we assume that the type is at index 1
    let type = path[1];

    // If the module is a scoped package, then the type will be at index 2
    if (path[0].charAt(0) === '@') {
      type = path[2];
    }

    return RESOLVED_TYPES.includes(type) && type;
  }

  _isResolvedType(module) {
    return this._resolvedTypeForModule(module);
  }

  _exportsForModuleOfResolvedTypes(module) {
    return [
      ...module.classes.map((item) => ({ type: 'classes', export: item })),
      ...module.components.map((item) => ({
        type: 'components',
        export: item,
      })),
    ];
  }

  _exportsForModuleOfNonResolvedTypes(module) {
    return [
      ...module.functions.map((item) => ({ type: 'functions', export: item })),
      ...module.variables.map((item) => ({ type: 'variables', export: item })),
    ];
  }

  _hasSingleExportOfResolvedType(module) {
    return (
      this._exportsForModuleOfResolvedTypes(module).length === 1 &&
      this._exportsForModuleOfNonResolvedTypes(module).length === 0
    );
  }

  _getNavItemForModule(module, type) {
    let navItem;

    if (this._isResolvedType(module)) {
      navItem = this._getNavItemForModuleOfResolvedType(module, type);
    } else if (this._hasSingleExportOfResolvedType(module)) {
      navItem = this._getNavItemForModuleWithSingleExport(module, type);
    } else {
      navItem = this._getNavItemForGenericModule(module, type);
    }

    return navItem;
  }

  _getNavItemForModuleOfResolvedType(module, type) {
    let segments = module.file.split('/');
    segments = segments.slice(segments.indexOf(type) + 1);

    if (type.match(segments[segments.length - 1])) {
      segments.pop();
    }

    let path = segments.join('/');
    let name;

    if (type === 'components') {
      let parts = segments.map((s) => _.upperFirst(_.camelCase(s)));
      let angleBracketName = parts.join('::');
      name = `<${angleBracketName}/>`;
    } else if (type === 'helpers') {
      name = `{{${path}}}`;
    } else {
      let fileName = segments.pop();
      name = _.upperFirst(_.camelCase(fileName));
    }

    return {
      id: module.id,
      path: `${type}/${path}`,
      name,
    };
  }

  _getNavItemForModuleWithSingleExport(module, type) {
    let singleExport = module[type][0];

    return {
      id: singleExport.id,
      path: `modules/${singleExport.id}`,
      name: singleExport.name,
    };
  }

  _getNavItemForGenericModule(module, type) {
    return {
      id: module.id,
      path: `modules/${module.id}`,
      name: module.id,
    };
  }
};

repository: ember-learn/ember-cli-addon-docs

repo_name: ember-learn/ember-cli-addon-docs

gha_language: JavaScript

extension: js


text:
@inproceedings{sagn2003intorduction,
  author = {Sang, Erik F. Tjong Kim and Meulder, Fien De},
  title = {Introduction to the CoNLL-2003 Shared Task: Language-Independent Named Entity Recognition},
  booktitle = {Proceedings of the Seventh Conference on Natural Language Learning at HLT-NAACL 2003},
  year = {2003},
  url = {http://www.aclweb.org/anthology/W03-0419}
}

url: https://raw.githubusercontent.com/Hugh-Shi/DL-NLP-Readings/924e4d189e5660c5b5d4854278f3df755ae2231d/Bibtex/Introduction to the CoNLL-2003 Shared Task -- Language-Independent Named Entity Recognition.bib

repository: Hugh-Shi/DL-NLP-Readings

repo_name: Hugh-Shi/DL-NLP-Readings


text:
package app

import (
	"fmt"
	"strings"

	"code.cloudfoundry.org/fissile/model"
	"code.cloudfoundry.org/fissile/validation"

	yaml "gopkg.in/yaml.v2"
)

// Validate applies a series of checks to the role
// manifest and opinions, testing for consistency against each other
// and the loaded bosh releases. The result is a (possibly empty)
// array of any issues found.
func (f *Fissile) Validate() validation.ErrorList {
	errors := make(chan *validation.Error)
	validator, err := newValidator(f, errors)
	if err != nil {
		return validation.ErrorList{err}
	}
	go validator.validate()
	allErrs := validation.ErrorList{}
	for err := range errors {
		allErrs = append(allErrs, err)
	}
	return allErrs
}

type validator struct {
	errOut        chan<- *validation.Error
	f             *Fissile
	lightOpinions map[string]string
	darkOpinions  map[string]string
	variableUsage map[string]int
}

func newValidator(f *Fissile, errOut chan<- *validation.Error) (*validator, *validation.Error) {
	opinions, err := model.NewOpinions(f.Options.LightOpinions, f.Options.DarkOpinions)
	if err != nil {
		return nil, validation.GeneralError("Light are dark opinions could not be read", err)
	}

	return &validator{
		errOut:        errOut,
		f:             f,
		lightOpinions: model.FlattenOpinions(opinions.Light, false),
		darkOpinions:  model.FlattenOpinions(opinions.Dark, false),
		variableUsage: make(map[string]int),
	}, nil
}

func (v *validator) validate() {
	defer close(v.errOut)

	allPropertyDefaults := v.f.collectPropertyDefaults()

	v.checkForSortedProperties(
		"configuration.templates",
		v.f.Manifest.Configuration.RawTemplates)

	for propertyName, templateDef := range v.f.Manifest.Configuration.Templates {
		if templateDef.IsGlobal {
			v.checkForUndefinedProperty(
				"configuration.templates",
				propertyName,
				allPropertyDefaults)
		}
	}

	// All light opinions must exists in a bosh release
	for lightProperty := range v.lightOpinions {
		v.checkForUndefinedProperty(
			"light opinion",
			lightProperty,
			allPropertyDefaults)
	}

	// All dark opinions must exists in a bosh release
	// This test is not necessary, as all dark opinions must be overridden by
	// some template, and all templates must come from a used job

	// All dark opinions must be configured as templates
	v.checkForUntemplatedDarkOpinions()

	// No dark opinions must have defaults in light opinions
	v.checkForDarkInTheLight()

	// No duplicates must exist between role manifest and light
	// opinions
	v.checkForDuplicatesBetweenManifestAndLight()

	for _, k := range model.MakeMapOfVariables(v.f.Manifest) {
		v.variableUsage[k.Name] = 0
		if k.CVOptions.Internal {
			// We always count internal variables as used
			v.variableUsage[k.Name]++
		}
	}

	for _, instanceGroup := range v.f.Manifest.InstanceGroups {
		label := fmt.Sprintf("instance_groups[%s].configuration.templates", instanceGroup.Name)
		// Collect the names of properties used in this instance group
		propertyDefaults := instanceGroup.CollectPropertyDefaults()
		for propertyName, templateDef := range instanceGroup.Configuration.Templates {
			if !templateDef.IsGlobal {
				v.checkForUndefinedProperty(label, propertyName, propertyDefaults)
				v.checkForUndefinedVariable(label, propertyName, templateDef.Value)
			}
		}
		v.checkForSortedProperties(
			label,
			instanceGroup.Configuration.RawTemplates)
	}

	// All light opinions should differ from their defaults in the
	// BOSH releases
	v.checkLightDefaults(allPropertyDefaults)

	v.checkTemplateInvalidExpansion()
	v.checkNonConstantTemplates()
	v.checkForSortedVariables(v.f.Manifest.Variables)
	for propertyName, templateDef := range v.f.Manifest.Configuration.Templates {
		if templateDef.IsGlobal {
			v.checkForUndefinedVariable("configuration.templates", propertyName, templateDef.Value)
		}
	}
	for variableName, variableUsageCount := range v.variableUsage {
		if variableUsageCount == 0 {
			v.errOut <- validation.NotFound(
				"variables",
				fmt.Sprintf("No templates using '%s'", variableName))
		}
	}
}

// checkForSortedProperties checks that the given ordered YAML map slice have
// all of its keys in order.
func (v *validator) checkForSortedProperties(label string, propertyOrder yaml.MapSlice) {
	var previous string
	for index, property := range propertyOrder {
		key := property.Key.(string)
		if index > 0 {
			if key < previous {
				v.errOut <- validation.Forbidden(
					fmt.Sprintf("%s[%s]", label, previous),
					fmt.Sprintf("Template key does not sort before '%s'", key))
			}
		}
		previous = key
	}
}

// checkForUndefinedProperty checks that a given property is known
func (v *validator) checkForUndefinedProperty(label, propertyName string, knownProperties model.PropertyDefaults) {

	// Ignore specials (without the "properties." prefix)
	if !strings.HasPrefix(propertyName, "properties.") {
		return
	}

	p := strings.TrimPrefix(propertyName, "properties.")
	if _, ok := knownProperties[p]; !ok {
		// The property as is was not found. This is
		// not necessarily an error. The "property"
		// may actually part of the value for a
		// structured (hash) property. To determine
		// this we walk the chain of parents to see if
		// any of them exist, and report an error only
		// if none of them do.

		if checkParentsOfUndefined(p, knownProperties) {
			return
		}

		v.errOut <- validation.NotFound(
			fmt.Sprintf("%s[%s]", label, propertyName),
			"In any used BOSH job")
	}
}

// checkParentsOfUndefined walks the chain of parents for `p` from the
// bottom up and checks if any of them exist. The elements of the
// chain are separated by dots.
func checkParentsOfUndefined(p string, defaults model.PropertyDefaults) bool {
	at := strings.LastIndex(p, ".")

	for at >= 0 {
		// While there is a dot in the property name we have a
		// parent to check the existence of

		parent := p[0:at]

		if pInfo, ok := defaults[parent]; ok {
			// We have a possible parent. Look if that
			// candidate may be a hash. If not our
			// property cannot be valid.

			if pInfo.MaybeHash {
				return true
			}

			return false
		}

		p = parent
		at = strings.LastIndex(p, ".")
	}

	return false
}

func (v *validator) checkForSortedVariables(variables model.Variables) {
	previousName := ""
	for _, cv := range variables {
		if cv.Name < previousName {
			v.errOut <- validation.Invalid("variables",
				previousName,
				fmt.Sprintf("Does not sort before '%s'", cv.Name))
		} else if cv.Name == previousName {
			v.errOut <- validation.Invalid("variables",
				previousName, "Appears more than once")
		}
		previousName = cv.Name
	}
}

// checkForUndefinedVariables checks that all configuration templates are
// defined in the variables section
func (v *validator) checkForUndefinedVariable(label, propertyName, templateValue string) {
	varsInTemplate, err := model.ParseTemplate(templateValue)
	if err != nil {
		// Ignore bad template, cannot have sensible
		// variable references
		return
	}
	for _, variable := range varsInTemplate {
		if _, ok := v.variableUsage[variable]; !ok {
			v.errOut <- validation.NotFound(
				fmt.Sprintf("%s[%s]", label, propertyName),
				fmt.Sprintf("No declaration of variable '%s'", variable))
		}
		// Unconditionally increment the usage counter; for variables that
		// are undeclared, this means we won't emit the same warning twice.
		v.variableUsage[variable]++
	}
}

// checkForUntemplatedDarkOpinions reports all dark opinions which are
// not configured as templates in the manifest.
func (v *validator) checkForUntemplatedDarkOpinions() {
	for property := range v.darkOpinions {
		if _, ok := v.f.Manifest.Configuration.Templates[property]; !ok {
			v.errOut <- validation.NotFound(property, "Dark opinion is missing template in role-manifest")
		}
	}

}

// checkForDarkInTheLight reports all dark opinions which have
// defaults in light opinions, which is forbidden
func (v *validator) checkForDarkInTheLight() {
	for property := range v.darkOpinions {
		if _, ok := v.lightOpinions[property]; ok {
			v.errOut <- validation.Forbidden(property, "Dark opinion found in light opinions")
		}
	}
}

// checkTemplateInvalidExpansion reports all templates with syntax errors
func (v *validator) checkTemplateInvalidExpansion() {
	// seenGlobalProperties keeps track of which global properties we've already
	// seen (and checked for duplicates in opinions).
	seenGlobalProperties := make(map[string]struct{})

	for _, instanceGroup := range v.f.Manifest.InstanceGroups {
		groupPrefix := fmt.Sprintf("instance_groups[%s].configuration.templates", instanceGroup.Name)
		for property, template := range instanceGroup.Configuration.Templates {
			prefix := groupPrefix
			if template.IsGlobal {
				if _, ok := seenGlobalProperties[property]; ok {
					continue
				}
				seenGlobalProperties[property] = struct{}{}
				prefix = "configuration.templates"
			}
			if _, err := model.ParseTemplate(template.Value); err != nil {
				v.errOut <- validation.Invalid(
					fmt.Sprintf("%s[%s]", prefix, property),
					template.Value,
					fmt.Sprintf("Template expansion error: %v", err))
			}
		}
	}
}

// checkForDuplicatesBetweenManifestAndLight reports all duplicates
// between role manifest and light opinions, i.e. properties defined
// in both.
func (v *validator) checkForDuplicatesBetweenManifestAndLight() {

	// seenGlobalProperties keeps track of which global properties we've already
	// seen (and checked for duplicates in opinions).
	seenGlobalProperties := make(map[string]struct{})

	for _, instanceGroup := range v.f.Manifest.InstanceGroups {
		groupPrefix := fmt.Sprintf("instance-groups[%s].configuration.templates", instanceGroup.Name)

		for property, template := range instanceGroup.Configuration.Templates {
			prefix := groupPrefix
			if template.IsGlobal {
				if _, ok := seenGlobalProperties[property]; ok {
					continue
				}
				seenGlobalProperties[property] = struct{}{}
				prefix = "configuration.templates"
			}
			if lightValue, ok := v.lightOpinions[property]; ok {
				if lightValue == template.Value {
					// The role manifest _could_ override the opinion, if the
					// opinion has literal values that needs to be run through
					// mustache.
					varsInTemplate, err := model.ParseTemplate(template.Value)
					if err != nil || len(varsInTemplate) == 0 {
						v.errOut <- validation.Forbidden(fmt.Sprintf("%s[%s]", prefix, property),
							"Role-manifest duplicates opinion, remove from manifest")
					}
				} else if template.IsGlobal {
					v.errOut <- validation.Forbidden(fmt.Sprintf("%s[%s]", prefix, property),
						"Role-manifest overrides opinion, remove opinion")
				}
			}
		}
	}
}

// checkLightDefaults reports all light opinions whose value is
// identical to their default in the BOSH releases
func (v *validator) checkLightDefaults(propertyDefaults model.PropertyDefaults) {
	for property, opinion := range v.lightOpinions {
		// Ignore specials (without the "properties." prefix)
		if !strings.HasPrefix(property, "properties.") {
			continue
		}

		// Ignore unknown/undefined property
		pInfo, ok := propertyDefaults[strings.TrimPrefix(property, "properties.")]
		if !ok {
			continue
		}

		// Ignore properties with ambiguous defaults.
		if len(pInfo.Defaults) > 1 {
			continue
		}

		if _, ok := pInfo.Defaults[opinion]; ok {
			v.errOut <- validation.Forbidden(property,
				fmt.Sprintf("Light opinion matches default of '%v'", opinion))
		}
	}
}

// checkNonConstantTemplates checks that all templates at the global level use
// some interprolation; constant values should be in opinions instead.
func (v *validator) checkNonConstantTemplates() {
	for key, template := range v.f.Manifest.Configuration.Templates {
		if !template.IsGlobal {
			// Non-global templates are allowed to be constant
			continue
		}
		varsInTemplate, err := model.ParseTemplate(template.Value)
		if err != nil {
			// Ignore bad template, cannot have sensible
			// variable references
			continue
		}
		if len(varsInTemplate) == 0 {
			v.errOut <- validation.Forbidden(
				fmt.Sprintf("configuration.templates[%s]", key),
				"Templates used as constants are not allowed")
		}
	}
}

repository: cloudfoundry-incubator/fissile

repo_name: cloudfoundry-incubator/fissile


text:
// This code is under BSD license. See license-bsd.txt
package main

import (
	"fmt"
	"net/http"
	"path/filepath"
)

func serveFileFromDir(w http.ResponseWriter, r *http.Request, dir, fileName string) {
	filePath := filepath.Join(dir, fileName)
	if !PathExists(filePath) {
		fmt.Printf("serveFileFromDir() file=%s doesn't exist\n", filePath)
	}
	http.ServeFile(w, r, filePath)
}

func serveFileStatic(w http.ResponseWriter, r *http.Request, fileName string) {
	serveFileFromDir(w, r, staticDir, fileName)
}

const lenStatic = len("/s/")

// url: /s/
func handleStatic(w http.ResponseWriter, r *http.Request) {
	file := r.URL.Path[lenStatic:]
	serveFileStatic(w, r, file)
}


text:
DESCRIPTION = "Freescale X11 Image"

include recipes-sato/images/core-image-sato.bb
inherit distro_features_check

REQUIRED_DISTRO_FEATURES = "x11"
CONFLICT_DISTRO_FEATURES = "directfb"

IMAGE_FEATURES += "debug-tweaks"
DISTRO_FEATURES += "pulseaudio"
WEB = "web-webkit"

SOC_EXTRA_IMAGE_FEATURES ?= "tools-testapps"

# Add extra image features
EXTRA_IMAGE_FEATURES += " \
    ${SOC_EXTRA_IMAGE_FEATURES} \
    nfs-server \
    tools-debug \
    tools-profile \
    qt4-pkgs \
"

SOC_IMAGE_INSTALL = ""
SOC_IMAGE_INSTALL_mx5 = "glcubes-demo"
SOC_IMAGE_INSTALL_mx6 =  "gpu-viv-g2d glmark2 fsl-gpu-sdk gst-plugins-gl-meta glcompbench"
SOC_IMAGE_INSTALL_mx6 += " xserver-xorg-extension-viv-hdmi"

IMAGE_INSTALL += " \
    ${SOC_IMAGE_INSTALL} \
    cpufrequtils \
    nano \
    packagegroup-fsl-gstreamer \
    packagegroup-fsl-tools-testapps \
    packagegroup-fsl-tools-benchmark \
    packagegroup-qt-in-use-demos \
    qt4-plugin-phonon-backend-gstreamer \
    qt4-demos \
    qt4-examples \
    fsl-gui-extrafiles \
    gtkperf \
    minicom \
    samba \
    gst-ffmpeg \
    gst-plugins-ugly-meta \
    gst-plugins-bad-meta \
    "

#pull this out of package group since v4l-utils now is x11 dependent
# and breaks non-x11 builds
RDEPENDS_${PN}-tools-testapps += " v4l-utils "

export IMAGE_BASENAME = "via-image-x11"


text:
# Copyright (C) 2022 Tanvi Chauhan <tanvi.chauhan@einfochips.com>
# Released under the MIT license (see COPYING.MIT for the terms)

DESCRIPTION = "Firmware files for AP1302 ISP camera sensors"
LICENSE = "CLOSED"

SRC_URI = "file://lib/firmware/ap1302_ar0430_fw.bin \
	   file://lib/firmware/ap1302_arx3a0_fw.bin \
	   file://lib/firmware/ap1302_ar1335_fw.bin \
	   file://lib/firmware/ap1302_ar0830_fw.bin \
		"
do_install() {
    install -d ${D}${base_libdir}/firmware/
    install -m 755 ${WORKDIR}/lib/firmware/* ${D}${base_libdir}/firmware/
}

FILES_${PN} += "${base_libdir}/firmware/ap1302_ar0430_fw.bin"
FILES_${PN} += "${base_libdir}/firmware/ap1302_arx3a0_fw.bin"
FILES_${PN} += "${base_libdir}/firmware/ap1302_ar1335_fw.bin"
FILES_${PN} += "${base_libdir}/firmware/ap1302_ar0830_fw.bin"


text:
@INPROCEEDINGS{Szott2008,
author={S. {Szott} and M. {Natkaniec} and R. {Canonico} and A. R. {Pach}},
booktitle={2008 IEEE Wireless Communications and Networking Conference},
title={{Impact of Contention Window Cheating on Single-Hop IEEE 802.11e MANETs}},
year={2008},
volume={},
number={},
pages={1356-1361},
keywords={ad hoc networks;IEEE standards;contention window cheating;single-hop IEEE 802.11e;MANET;node misbehavior;contention window manipulation;ad-hoc network;uplink traffic;downlink traffic;Ad hoc networks;Quality of service;Downlink;Telecommunication traffic;Traffic control;Communications Society;Wireless LAN;Transport protocols;Wireless networks;Multiaccess communication},
doi={10.1109/WCNC.2008.244},
ISSN={1525-3511},
month={March},}

repository: SzymonSzott/academic-kickstart

repo_name: SzymonSzott/academic-kickstart


text:
require dtc.inc

PR = "r1"

SRC_URI = "http://www.jdl.com/pub/software/dtc-${PV}.tgz"

S = "${WORKDIR}/dtc"

SRC_URI[md5sum] = "8762121262ead127171c4fce40ccc289"
SRC_URI[sha256sum] = "dd687b4f691bf9970f53ca2c84d8481b9f82d857de347375d29bacf648b8da71"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
package vehicle

import (
	"time"

	"github.com/evcc-io/evcc/api"
	"github.com/evcc-io/evcc/util"
	"github.com/evcc-io/evcc/vehicle/volvo/connected"
)

// VolvoConnected is an api.Vehicle implementation for Volvo Connected Car vehicles
type VolvoConnected struct {
	*embed
	*connected.Provider
}

func init() {
	registry.Add("volvo-connected", NewVolvoConnectedFromConfig)
}

// NewVolvoConnectedFromConfig creates a new VolvoConnected vehicle
func NewVolvoConnectedFromConfig(other map[string]interface{}) (api.Vehicle, error) {
	cc := struct {
		embed          `mapstructure:",squash"`
		User, Password string
		VIN            string
		// ClientID, ClientSecret string
		// Sandbox                bool
		VccApiKey string
		Cache     time.Duration
	}{
		Cache: interval,
	}

	if err := util.DecodeOther(other, &cc); err != nil {
		return nil, err
	}

	if cc.User == "" || cc.Password == "" {
		return nil, api.ErrMissingCredentials
	}

	// if cc.ClientID == "" && cc.ClientSecret == "" {
	// 	return nil, errors.New("missing credentials")
	// }

	// var options []VolvoConnected.IdentityOptions

	// TODO Load tokens from a persistence storage and use those during startup
	// e.g. persistence.Load("key")
	// if tokens != nil {
	// 	options = append(options, VolvoConnected.WithToken(&oauth2.Token{
	// 		AccessToken:  tokens.Access,
	// 		RefreshToken: tokens.Refresh,
	// 		Expiry:       tokens.Expiry,
	// 	}))
	// }

	log := util.NewLogger("volvo-cc").Redact(cc.User, cc.Password, cc.VIN, cc.VccApiKey)

	// identity, err := connected.NewIdentity(log, cc.ClientID, cc.ClientSecret)
	identity, err := connected.NewIdentity(log)
	if err != nil {
		return nil, err
	}

	ts, err := identity.Login(cc.User, cc.Password)
	if err != nil {
		return nil, err
	}

	// api := connected.NewAPI(log, identity, cc.Sandbox)
	api := connected.NewAPI(log, ts, cc.VccApiKey)

	cc.VIN, err = ensureVehicle(cc.VIN, api.Vehicles)

	v := &VolvoConnected{
		embed:    &cc.embed,
		Provider: connected.NewProvider(api, cc.VIN, cc.Cache),
	}

	return v, err
}

repository: DerAndereAndi/evcc

repo_name: DerAndereAndi/evcc


text:
SUMMARY = "Contains some simple helper functions for calling fcntl.ioctl()"
HOMEPAGE = "https://github.com/olavmrk/python-ioctl"
SECTION = "devel/python"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=c89cfb68b1a0b82784ad4b8ddc058eba"
DEPENDS = "python-setuptools-scm-native"
SRCREV = "1f090606fb5b68cd4cd98a3eb18fd4a571fc931c"
PV = "0.0.2+git${SRCPV}"

SRC_URI = "git://github.com/olavmrk/python-ioctl"

S = "${WORKDIR}/git"

inherit setuptools

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

repository: opendreambox/opendreambox

repo_name: opendreambox/opendreambox

branch_name: refs/heads/pyro

gha_license_id: NOASSERTION

gha_language: BitBake


text:
SUMMARY = "Pure-JavaScript CSS selector engine"
HOMEPAGE = "https://github.com/jquery/sizzle/wiki"
LICENSE = "GPL-2.0-only & MIT & AFL-2.1"
LIC_FILES_CHKSUM = "file://MIT-LICENSE.txt;md5=e43aa437a6a1ba421653bd5034333bf9"

SRC_URI = "http://kr.archive.ubuntu.com/ubuntu/pool/universe/s/sizzle/sizzle_1.10.18.orig.tar.gz"
SRC_URI[md5sum] = "91477c1edeef9f8100ffd6c4d31725b5"
SRC_URI[sha256sum] = "8e04ab84bb74b2e338dffc63cd2e52b007f1d8af01b3d25da4d2e07f2b5890f8"

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

SIZZLEDIR = "${S}/dist"

do_install() {
    install -d -m 0755 ${D}/${datadir}/javascript/sizzle/
    install -m 0644 ${SIZZLEDIR}/*.js ${D}/${datadir}/javascript/sizzle/
}

FILES:${PN} = "${datadir}/javascript/sizzle/"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
var fs = require('fs'),
  crypto = require('easycrypto').getInstance(),
  contents = {},
  pwd, vault;

/**
 * Constructor.  It is not recommended
 * that instances of SysVault be directly instantiated.
 * Please use the getInstance() factory method with a
 * corresponding config.
 *
 * @param config
 * @constructor
 */
var SysVault = function(config) {
  pwd = config.pwd;
  vault = config.vault || ".sysvault";
  this.init();
};

/**
 * Initializes an empty sysvault file if one
 * does not currently exist.
 */
SysVault.prototype.init = function() {
  var encrypted, raw;
  if (fs.existsSync(vault)) {
    encrypted = fs.readFileSync(vault, 'utf8');
    raw = crypto.decrypt(encrypted, pwd);
    contents = JSON.parse(raw);
  } else {
    this.flush();
  };
};

/**
 * Adds a key/value pair to the vault cache.  Value
 * can be later retrieved with the same key and the get()
 * method.  Value is transient until flush() is invoked.
 *
 * @param key
 * @param value
 */
SysVault.prototype.put = function(key, value) {
  contents[key] = value;
};

/**
 * Returns the value of a cache item
 * with the provided key.  If no such key
 * exists, then undefined will be returned.
 *
 * @param key
 * @return {*}
 */
SysVault.prototype.get = function(key) {
  return contents[key];
};

/**
 * Persists all transient cache data to the local
 * encrypted .sysvault file.  Will persist the cache
 * synchronously if no callback is provided when invoking
 * flush().  If a callback function is provided as a parameter
 * then persistence will happen asynchronously and that
 * callback will be invoked when the operation is complete,
 * passing in an optional error object if a problem
 * persisting the data occurs.
 *
 * @param callback
 */
SysVault.prototype.flush = function(callback) {
  var raw = JSON.stringify(contents);
  var encrypted = crypto.encrypt(raw, pwd);
  if (callback) {
    fs.writeFile(vault, encrypted, 'utf8', callback);
  } else {
    fs.writeFileSync(vault, encrypted, 'utf8');
  }
};

/**
 * Factory method used to instantiate SysVault instances.
 * Instances must be configured with a password 'pwd' which will
 * be used to encrypt and persist transient cache data when
 * flush() is called;
 *
 * ...sysvault.getInstance({
 *   pwd: 'some password'
 * });
 *
 * If an instance is created with a different password that was
 * used to originally encrypt the data, any calls to flush will
 * fail with an encrypt error.
 *
 * Any number of individual vault files can be created (associated
 * to specific instances of SysVault) by providing a 'vault' config value;
 *
 * ...sysvault.getInstance({
 *   vault: 'somefilename'
 * });
 *
 * @param config
 * @return {SysVault}
 */
exports.getInstance = function(config) {
  return new SysVault(config || {});
};

repository: mrmarbles/sysvault

repo_name: mrmarbles/sysvault


text:
@article{donhauser2015implicit,
  title={The implicit need for power predicts recognition speed for dynamic changes in facial expressions of emotion},
  author={Donhauser, Peter W and R{\"o}sch, Andreas G and Schultheiss, Oliver C},
  journal={Motivation and Emotion},
  volume={39},
  number={5},
  pages={714--721},
  year={2015},
  publisher={Springer}
}

repository: pwdonh/starter-academic

repo_name: pwdonh/starter-academic


text:
package bounded_queue

type Queue struct{
	ch chan int
}

func New(cap int)*Queue{
	return &Queue{ch:make(chan int, cap)}
}

func (q *Queue)Enq(x int){
	q.ch <- x
}

func (q *Queue)Deq()int{
	n := <-q.ch
	return n
}

repository: bjhua/concur

repo_name: bjhua/concur


text:
package p052

func totalNQueens(n int) int {
	locations := make([]int, n)
	res := 0
	cols := make([]bool, n)
	r45 := make([]bool, n*2-1)
	r135 := make([]bool, n*2-1)

	var solve func(nth int)

	solve = func(nth int) {
		for i := 0; i < n; i++ {
			if cols[i] || r45[n-1-nth+i] || r135[nth+i] {
				continue
			} else {
				cols[i] = true
				r45[n-1-nth+i] = true
				r135[nth+i] = true
				locations[nth] = i
			}

			if nth == n-1 {
				res += 1
			} else {
				solve(nth + 1)
			}
			cols[i] = false
			r45[n-1-nth+i] = false
			r135[nth+i] = false
		}
	}

	solve(0)

	//fmt.Println(res)
	return res
}

repository: baishuai/leetcode

repo_name: baishuai/leetcode


text:
SUMMARY = "Support for having multipath iSCSI devices as root file system"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/COPYING.MIT;md5=3da9cfbcb788c80a0384361b4de20420"
SRC_URI = "file://init-boot.sh \
"

do_install() {
        install -m 0755 ${WORKDIR}/init-boot.sh ${D}/init
}

inherit allarch

RDEPENDS_${PN} += "multipath-tools kpartx iscsi-initiator-utils"

FILES_${PN} += " /init "

repository: Joleme/meta-cgl

repo_name: Joleme/meta-cgl


text:
@article{Zhou_2007_jan,
 author = {Junli Zhou and Xiangfeng Wang and Yuling Jiao and Yonghua Qin and Xigang Liu and Kun He and Chen Chen and Ligeng Ma and Jian Wang and Lizhong Xiong and Qifa Zhang and Liumin Fan and Xing Wang Deng},
 doi = {10.1007/s11103-006-9111-1},
 journal = {Plant Mol Biol},
 month = {jan},
 number = {5},
 pages = {591--608},
 publisher = {Springer Science and Business Media LLC},
 title = {Global genome expression analysis of rice in response to drought and high-salinity stresses in shoot, flag leaf, and panicle},
 url = {https://doi.org/10.1007%2Fs11103-006-9111-1},
 volume = {63},
 year = {2007}
}

repository: wanglab-cau/CrazyHsu

repo_name: wanglab-cau/CrazyHsu


text:
DESCRIPTION = "TPM C library for use with Azure IoT SDKs"
AUTHOR = "Microsoft Corporation"
HOMEPAGE = "https://github.com/Azure/azure-utpm-c"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=27e94c0280987ab296b0b8dd02ab9fe5"

SRC_URI = "\
	git://github.com/Azure/azure-utpm-c.git \
"

SRCREV = "da41b478b7905c7646bb3a03de1ce689f293d974"

PR = "r0"

require ${PN}.inc

repository: derekstraka/meta-iot-cloud

repo_name: derekstraka/meta-iot-cloud


text:
require bsf_${PV}.bb

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

inherit java-native

DEPENDS = "fastjar-native jacl-native commons-logging-native rhino-native xalan-j-native bcel-native"

repository: demsey/openembedded

repo_name: demsey/openembedded


text:
@INPROCEEDINGS{lee16,
author={M. Lee and K. Kim and S. Daher and A. Raij and R. Schubert and J. Bailenson and G. Welch},
booktitle={2016 IEEE Virtual Reality (VR)},
title={The wobbly table: Increased social presence via subtle incidental movement of a real-virtual table},
year={2016},
volume={},
number={},
pages={11-17},
keywords={human computer interaction;virtual reality;Twenty Questions game;human-VH interaction;human-virtual human interaction;object movement;projection screen;real-virtual room;real-virtual table;shared real-virtual object;social presence;subtle incidental movement;virtual world;wobbly table;Electronic mail;Force;Games;Haptic interfaces;Measurement by laser beam;Training;Virtual environments;H.5.1 [Information Interfaces and Presentation]: Multimedia Information Systems — Artificial, Augmented and Virtual Realities;J.4 [Computer Applications]: Social and Behavioral Sciences — Psychology},
doi={10.1109/VR.2016.7504683},
ISSN={},
month={March},}

gha_language: TeX


text:
@article{sun2014enabling,
  title={Enabling emergency communication through a cognitive radio vehicular network},
  author={Sun, Yifan and Chowdhury, Kaushik R},
  journal={IEEE Communications Magazine},
  volume={52},
  number={10},
  pages={68--75},
  year={2014},
  publisher={IEEE}
}

gha_language: HTML


text:
require x-load.inc

DEFAULT_PREFERENCE_omap3-pandora = "-1"

FILESDIR = "${@os.path.dirname(bb.data.getVar('FILE',d,1))}/x-load-git/${MACHINE}"

SRCREV = "319b26586fafb86f919f514bcd175838aaab96b3"
SRCREV_beagleboard = "1c9276af4d6a5b7014a7630a1abeddf3b3177563"

PV = "1.42+${PR}+gitr${SRCREV}"
PV_beagleboard = "1.44+${PR}+gitr${SRCREV}"
PR ="r17"
PE = "1"

SRC_URI = "git://gitorious.org/x-load-omap3/mainline.git;branch=master;protocol=git"

SRC_URI_append_beagleboard = " \
                              file://name.patch \
                              file://bb8547fcbc54ecc7a75f9ad45a31042a04d8a2ce.patch \
                              file://xm-mem.patch \
                              file://0001-Fix-reading-FAT32-root-dirs-that-span-1-cluster.patch \
"

SRC_URI_append_omap3-touchbook = " \
                              file://name.patch \
                              file://screen-off.patch \
                             "

# TI PSP v1.46_OMAPPSP_03.00.01.06 (Tag is one commit different)
SRC_URI_omap3evm = "git://arago-project.org/git/projects/x-load-omap3.git;protocol=git"
SRCREV_omap3evm = "fc6d5be15c703d21aef0ae0b8c02177721f0445f"
PV_omap3evm = "1.46+${PR}+gitr${SRCREV}"

# TI PSP v1.46_OMAPPSP_03.00.01.06 (Tag is one commit different)
SRC_URI_dm37x-evm = "git://arago-project.org/git/projects/x-load-omap3.git;protocol=git"
SRCREV_dm37x-evm = "fc6d5be15c703d21aef0ae0b8c02177721f0445f"
PV_dm37x-evm = "1.46+${PR}+gitr${SRCREV}"

# TI PSP v1.46_OMAPPSP_03.00.01.06 (Tag is one commit different)
SRC_URI_am37x-evm = "git://arago-project.org/git/projects/x-load-omap3.git;protocol=git"
SRCREV_am37x-evm = "fc6d5be15c703d21aef0ae0b8c02177721f0445f"
PV_am37x-evm = "1.46+${PR}+gitr${SRCREV}"

# TI PSP v1.46_OMAPPSP_03.00.01.06 (Tag is one commit different)
SRC_URI_am3517-evm = "git://arago-project.org/git/projects/x-load-omap3.git;protocol=git"
SRCREV_am3517-evm = "fc6d5be15c703d21aef0ae0b8c02177721f0445f"
PV_am3517-evm = "1.46+${PR}+gitr${SRCREV}"

SRC_URI_omapzoom2 = "git://dev.omapzoom.org/pub/scm/bootloader/x-loader.git;protocol=git \
                     http://www.xora.org.uk/~dp/oe/zoom2.u-boot.git_78e778e0ea884306841c6499851a1e35177d81d0.tar.gz;name=uboot"
SRCREV_omapzoom2 = "599c6cb87ee0c01fd6632b24f6d7e0a2b3ea5d0a"

SRC_URI_omapzoom36x = "git://dev.omapzoom.org/pub/scm/bootloader/x-loader.git;protocol=git \
                       http://www.xora.org.uk/~dp/oe/zoom2.u-boot.git_78e778e0ea884306841c6499851a1e35177d81d0.tar.gz;name=uboot"
SRCREV_omapzoom36x = "251d92815500143aefdbe3b3558a0ce6daeaebdc"

SRC_URI[uboot.md5sum] = "e68b30714d22ce2f926d2dd19f94a2be"
SRC_URI[uboot.sha256sum] = "e7e5c87d939cc4c1f14d17ea0814b0bed97021c7afca3ef9053c896c2b5bdd6f"

SRC_URI_igep0020 = "git://git.igep.es/pub/scm/x-loader.git;protocol=git \
                    file://remove-final-ldflags.patch"
SRCREV_igep0020 = "213d95fcadc54424c796259928d7c15c5a2945a0"
PV_igep0020 = "1.43+${PR}+gitr${SRCREV}"

S = "${WORKDIR}/git"

PACKAGE_ARCH = "${MACHINE_ARCH}"

repository: trini/openembedded

repo_name: trini/openembedded


text:
package main

import (
	"flag"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"strings"

	"github.com/goproxyio/goproxy/module"
)

var cacheDir string
var listen string

func init() {
	flag.StringVar(&listen, "listen", "0.0.0.0:8081", "service listen address")
	flag.Parse()
}

func main() {
	gpEnv := os.Getenv("GOPATH")
	if gpEnv == "" {
		panic("can not find $GOPATH")
	}
	gp := filepath.SplitList(gpEnv)
	cacheDir = filepath.Join(gp[0], "pkg", "mod", "cache", "download")
	http.Handle("/", mainHandler(http.FileServer(http.Dir(cacheDir))))
	err := http.ListenAndServe(listen, nil)
	if nil != err {
		panic(err)
	}
}

func mainHandler(inner http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(os.Stdout, "goproxy: %s download %s\n", r.RemoteAddr, r.URL.Path)
		if _, err := os.Stat(filepath.Join(cacheDir, r.URL.Path)); err != nil {
			if strings.HasSuffix(r.URL.Path, ".info") || strings.HasSuffix(r.URL.Path, ".mod") {
				suffix := ".mod"
				if strings.HasSuffix(r.URL.Path, ".info") {
					suffix = ".info"
				}
				mod := strings.Split(r.URL.Path, "/@v/")
				if len(mod) != 2 {
					ReturnServerError(w, fmt.Errorf("bad module path:%s", r.URL.Path))
					return
				}
				version := strings.TrimSuffix(mod[1], suffix)
				version, err = module.DecodeVersion(version)
				if err != nil {
					ReturnServerError(w, err)
					return
				}
				path := strings.TrimPrefix(mod[0], "/")
				path, err := module.DecodePath(path)
				if err != nil {
					ReturnServerError(w, err)
					return
				}
				// ignore the error, incorrect tag may be given
				// forward to inner.ServeHTTP
				goGet(path, version, suffix, w, r)
			}
			if strings.HasSuffix(r.URL.Path, "/@v/list") {
				w.Write([]byte(""))
				return
			}
		}
		inner.ServeHTTP(w, r)
	})
}

func goGet(path, version, suffix string, w http.ResponseWriter, r *http.Request) error {
	cmd := exec.Command("go", "get", "-d", path+"@"+version)
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return err
	}

	stderr, err := cmd.StderrPipe()
	if err != nil {
		return err
	}

	if err := cmd.Start(); err != nil {
		return err
	}

	bytesErr, err := ioutil.ReadAll(stderr)
	if err != nil {
		return err
	}

	_, err = ioutil.ReadAll(stdout)
	if err != nil {
		return err
	}

	if err := cmd.Wait(); err != nil {
		fmt.Fprintf(os.Stderr, "goproxy: download %s stderr:\n%s", path, string(bytesErr))
		return err
	}
	out := fmt.Sprintf("%s", bytesErr)

	for _, line := range strings.Split(out, "\n") {
		f := strings.Fields(line)
		if len(f) != 4 {
			continue
		}
		if f[1] == "downloading" && f[2] == path && f[3] != version {
			h := r.Host
			mod := strings.Split(r.URL.Path, "/@v/")
			p := fmt.Sprintf("%s/@v/%s%s", mod[0], f[3], suffix)
			scheme := "http:"
			if r.TLS != nil {
				scheme = "https:"
			}
			url := fmt.Sprintf("%s//%s/%s", scheme, h, p)
			http.Redirect(w, r, url, 302)
		}
	}
	return nil
}

repository: wonsikin/goproxy

repo_name: wonsikin/goproxy


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

package analysis_go_proto

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	any "github.com/golang/protobuf/ptypes/any"
	storage_go_proto "kythe.io/kythe/proto/storage_go_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 AnalysisResult_Status int32

const (
	AnalysisResult_COMPLETE        AnalysisResult_Status = 0
	AnalysisResult_INCOMPLETE      AnalysisResult_Status = 1
	AnalysisResult_INVALID_REQUEST AnalysisResult_Status = 2
)

var AnalysisResult_Status_name = map[int32]string{
	0: "COMPLETE",
	1: "INCOMPLETE",
	2: "INVALID_REQUEST",
}

var AnalysisResult_Status_value = map[string]int32{
	"COMPLETE":        0,
	"INCOMPLETE":      1,
	"INVALID_REQUEST": 2,
}

func (x AnalysisResult_Status) String() string {
	return proto.EnumName(AnalysisResult_Status_name, int32(x))
}

func (AnalysisResult_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8e4ea7eca60afe48, []int{2, 0}
}

type AnalysisRequest struct {
	Compilation          *CompilationUnit `protobuf:"bytes,1,opt,name=compilation,proto3" json:"compilation,omitempty"`
	FileDataService      string           `protobuf:"bytes,2,opt,name=file_data_service,json=fileDataService,proto3" json:"file_data_service,omitempty"`
	Revision             string           `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
	BuildId              string           `protobuf:"bytes,4,opt,name=build_id,json=buildId,proto3" json:"build_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_AnalysisRequest proto.InternalMessageInfo

func (m *AnalysisRequest) GetCompilation() *CompilationUnit {
	if m != nil {
		return m.Compilation
	}
	return nil
}

func (m *AnalysisRequest) GetFileDataService() string {
	if m != nil {
		return m.FileDataService
	}
	return ""
}

func (m *AnalysisRequest) GetRevision() string {
	if m != nil {
		return m.Revision
	}
	return ""
}

func (m *AnalysisRequest) GetBuildId() string {
	if m != nil {
		return m.BuildId
	}
	return ""
}

type AnalysisOutput struct {
	Value                []byte          `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	FinalResult          *AnalysisResult `protobuf:"bytes,10,opt,name=final_result,json=finalResult,proto3" json:"final_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_AnalysisOutput proto.InternalMessageInfo

func (m *AnalysisOutput) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *AnalysisOutput) GetFinalResult() *AnalysisResult {
	if m != nil {
		return m.FinalResult
	}
	return nil
}

type AnalysisResult struct {
	Status               AnalysisResult_Status `protobuf:"varint,1,opt,name=status,proto3,enum=kythe.proto.AnalysisResult_Status" json:"status,omitempty"`
	Summary              string                `protobuf:"bytes,2,opt,name=summary,proto3" json:"summary,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_AnalysisResult proto.InternalMessageInfo

func (m *AnalysisResult) GetStatus() AnalysisResult_Status {
	if m != nil {
		return m.Status
	}
	return AnalysisResult_COMPLETE
}

func (m *AnalysisResult) GetSummary() string {
	if m != nil {
		return m.Summary
	}
	return ""
}

type CompilationUnit struct {
	VName                *storage_go_proto.VName      `protobuf:"bytes,1,opt,name=v_name,json=vName,proto3" json:"v_name,omitempty"`
	RequiredInput        []*CompilationUnit_FileInput `protobuf:"bytes,3,rep,name=required_input,json=requiredInput,proto3" json:"required_input,omitempty"`
	HasCompileErrors     bool                         `protobuf:"varint,4,opt,name=has_compile_errors,json=hasCompileErrors,proto3" json:"has_compile_errors,omitempty"`
	Argument             []string                     `protobuf:"bytes,5,rep,name=argument,proto3" json:"argument,omitempty"`
	SourceFile           []string                     `protobuf:"bytes,6,rep,name=source_file,json=sourceFile,proto3" json:"source_file,omitempty"`
	OutputKey            string                       `protobuf:"bytes,7,opt,name=output_key,json=outputKey,proto3" json:"output_key,omitempty"`
	WorkingDirectory     string                       `protobuf:"bytes,8,opt,name=working_directory,json=workingDirectory,proto3" json:"working_directory,omitempty"`
	EntryContext         string                       `protobuf:"bytes,9,opt,name=entry_context,json=entryContext,proto3" json:"entry_context,omitempty"`
	Environment          []*CompilationUnit_Env       `protobuf:"bytes,10,rep,name=environment,proto3" json:"environment,omitempty"`
	Details              []*any.Any                   `protobuf:"bytes,11,rep,name=details,proto3" json:"details,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

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

var xxx_messageInfo_CompilationUnit proto.InternalMessageInfo

func (m *CompilationUnit) GetVName() *storage_go_proto.VName {
	if m != nil {
		return m.VName
	}
	return nil
}

func (m *CompilationUnit) GetRequiredInput() []*CompilationUnit_FileInput {
	if m != nil {
		return m.RequiredInput
	}
	return nil
}

func (m *CompilationUnit) GetHasCompileErrors() bool {
	if m != nil {
		return m.HasCompileErrors
	}
	return false
}

func (m *CompilationUnit) GetArgument() []string {
	if m != nil {
		return m.Argument
	}
	return nil
}

func (m *CompilationUnit) GetSourceFile() []string {
	if m != nil {
		return m.SourceFile
	}
	return nil
}

func (m *CompilationUnit) GetOutputKey() string {
	if m != nil {
		return m.OutputKey
	}
	return ""
}

func (m *CompilationUnit) GetWorkingDirectory() string {
	if m != nil {
		return m.WorkingDirectory
	}
	return ""
}

func (m *CompilationUnit) GetEntryContext() string {
	if m != nil {
		return m.EntryContext
	}
	return ""
}

func (m *CompilationUnit) GetEnvironment() []*CompilationUnit_Env {
	if m != nil {
		return m.Environment
	}
	return nil
}

func (m *CompilationUnit) GetDetails() []*any.Any {
	if m != nil {
		return m.Details
	}
	return nil
}

type CompilationUnit_FileInput struct {
	VName                *storage_go_proto.VName `protobuf:"bytes,1,opt,name=v_name,json=vName,proto3" json:"v_name,omitempty"`
	Info                 *FileInfo               `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	Details              []*any.Any              `protobuf:"bytes,4,rep,name=details,proto3" json:"details,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_CompilationUnit_FileInput proto.InternalMessageInfo

func (m *CompilationUnit_FileInput) GetVName() *storage_go_proto.VName {
	if m != nil {
		return m.VName
	}
	return nil
}

func (m *CompilationUnit_FileInput) GetInfo() *FileInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *CompilationUnit_FileInput) GetDetails() []*any.Any {
	if m != nil {
		return m.Details
	}
	return nil
}

type CompilationUnit_Env struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CompilationUnit_Env proto.InternalMessageInfo

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

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

type FilesRequest struct {
	Files                []*FileInfo `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_FilesRequest proto.InternalMessageInfo

func (m *FilesRequest) GetFiles() []*FileInfo {
	if m != nil {
		return m.Files
	}
	return nil
}

type FileInfo struct {
	Path                 string   `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Digest               string   `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_FileInfo proto.InternalMessageInfo

func (m *FileInfo) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *FileInfo) GetDigest() string {
	if m != nil {
		return m.Digest
	}
	return ""
}

type FileData struct {
	Content              []byte    `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
	Info                 *FileInfo `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	Missing              bool      `protobuf:"varint,3,opt,name=missing,proto3" json:"missing,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

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

var xxx_messageInfo_FileData proto.InternalMessageInfo

func (m *FileData) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

func (m *FileData) GetInfo() *FileInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *FileData) GetMissing() bool {
	if m != nil {
		return m.Missing
	}
	return false
}

type CompilationBundle struct {
	Unit                 *CompilationUnit `protobuf:"bytes,1,opt,name=unit,proto3" json:"unit,omitempty"`
	Files                []*FileData      `protobuf:"bytes,2,rep,name=files,proto3" json:"files,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_CompilationBundle proto.InternalMessageInfo

func (m *CompilationBundle) GetUnit() *CompilationUnit {
	if m != nil {
		return m.Unit
	}
	return nil
}

func (m *CompilationBundle) GetFiles() []*FileData {
	if m != nil {
		return m.Files
	}
	return nil
}

type IndexedCompilation struct {
	Unit                 *CompilationUnit          `protobuf:"bytes,1,opt,name=unit,proto3" json:"unit,omitempty"`
	Index                *IndexedCompilation_Index `protobuf:"bytes,2,opt,name=index,proto3" json:"index,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

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

var xxx_messageInfo_IndexedCompilation proto.InternalMessageInfo

func (m *IndexedCompilation) GetUnit() *CompilationUnit {
	if m != nil {
		return m.Unit
	}
	return nil
}

func (m *IndexedCompilation) GetIndex() *IndexedCompilation_Index {
	if m != nil {
		return m.Index
	}
	return nil
}

type IndexedCompilation_Index struct {
	Revisions            []string `protobuf:"bytes,1,rep,name=revisions,proto3" json:"revisions,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_IndexedCompilation_Index proto.InternalMessageInfo

func (m *IndexedCompilation_Index) GetRevisions() []string {
	if m != nil {
		return m.Revisions
	}
	return nil
}

func init() {
	proto.RegisterEnum("kythe.proto.AnalysisResult_Status", AnalysisResult_Status_name, AnalysisResult_Status_value)
	proto.RegisterType((*AnalysisRequest)(nil), "kythe.proto.AnalysisRequest")
	proto.RegisterType((*AnalysisOutput)(nil), "kythe.proto.AnalysisOutput")
	proto.RegisterType((*AnalysisResult)(nil), "kythe.proto.AnalysisResult")
	proto.RegisterType((*CompilationUnit)(nil), "kythe.proto.CompilationUnit")
	proto.RegisterType((*CompilationUnit_FileInput)(nil), "kythe.proto.CompilationUnit.FileInput")
	proto.RegisterType((*CompilationUnit_Env)(nil), "kythe.proto.CompilationUnit.Env")
	proto.RegisterType((*FilesRequest)(nil), "kythe.proto.FilesRequest")
	proto.RegisterType((*FileInfo)(nil), "kythe.proto.FileInfo")
	proto.RegisterType((*FileData)(nil), "kythe.proto.FileData")
	proto.RegisterType((*CompilationBundle)(nil), "kythe.proto.CompilationBundle")
	proto.RegisterType((*IndexedCompilation)(nil), "kythe.proto.IndexedCompilation")
	proto.RegisterType((*IndexedCompilation_Index)(nil), "kythe.proto.IndexedCompilation.Index")
}

func init() { proto.RegisterFile("kythe/proto/analysis.proto", fileDescriptor_8e4ea7eca60afe48) }

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

repository: zzmp/kythe

repo_name: zzmp/kythe


text:
@article{Agrawal:2015dbf,
 archiveprefix = {arXiv},
 author = {Agrawal, Prateek and Fan, JiJi and Heidenreich, Ben and Reece, Matthew and Strassler, Matthew},
 doi = {10.1007/JHEP06(2016)082},
 eprint = {1512.05775},
 journal = {JHEP},
 pages = {082},
 primaryclass = {hep-ph},
 title = {Experimental Considerations Motivated by the Diphoton Excess at the LHC},
 volume = {06},
 year = {2016}
}

repository: prateekagrawal/academic-kickstart

repo_name: prateekagrawal/academic-kickstart


text:
@article{sajobi2015identifying,
 author = {Sajobi, Tolulope T and Lix, Lisa M and Singh, Gurbakhshash and Lowerison, Mark and Engbers, Jordan and Mayo, Nancy E},
 journal = {Quality of Life Research},
 number = {3},
 pages = {529--540},
 publisher = {Springer International Publishing},
 title = {Identifying reprioritization response shift in a stroke caregiver population: a comparison of missing data methods},
 volume = {24},
 year = {2015}
}


text:
SUMMARY = "A small image just capable of allowing a device to boot."

RATIONALIST_PKGS = "\
 avahi-daemon\
 dmidecode\
 expat\
 flashrom\
 htop\
 i2c-tools\
 initscripts\
 iproute2\
 iproute2-bridge\
 iproute2-tc\
 iptables\
 jittertrap\
 jittertrap-dbg\
 kernel-modules\
 less\
 kmod\
 netbase\
 openssh\
 shadow\
 shadow-securetty\
 systemd\
 systemd-compat-units\
 systemd-serialgetty\
 tcpdump\
 update-alternatives-opkg\
 update-rc.d\
 util-linux-agetty\
 util-linux-libblkid\
 util-linux-libmount\
 util-linux-libuuid\
 util-linux-mount\
"

DEPENDS = "parted-native python-smartpm"

CONFIG_PKGS = "trap-machine-config"

# read-only-rootfs breaks ssh config, specifically ssh_allow_empty_password
#IMAGE_FEATURES += "package-management ssh-server-openssh read-only-rootfs"
IMAGE_FEATURES += "package-management ssh-server-openssh post-install-logging"

IMAGE_INSTALL = "\
 packagegroup-core-boot\
 ${ROOTFS_PKGMANAGE_BOOTSTRAP}\
 ${CORE_IMAGE_EXTRA_INSTALL}\
 ${RATIONALIST_PKGS}\
 ${CONFIG_PKGS}\
 run-postinsts\
"

IMAGE_LINGUAS = " "

LICENSE = "MIT"

inherit core-image

IMAGE_ROOTFS_SIZE ?= "8192"

set_root_password() {
}

add_custom_smart_config() {
	smart --data-dir=${IMAGE_ROOTFS}/var/lib/smart\
		channel -y --add mousetrap_hw \
		type=rpm-md\
		name="Jittertrap mousetrap_hw Package Repository"\
		baseurl=http://testing.jittertrap.com/mousetrap/rpm/mousetrap_hw

	smart --data-dir=${IMAGE_ROOTFS}/var/lib/smart\
		channel -y --add all \
		type=rpm-md\
		name="Jittertrap all hw Package Repository"\
		baseurl=http://testing.jittertrap.com/mousetrap/rpm/all

	smart --data-dir=${IMAGE_ROOTFS}/var/lib/smart\
		channel -y --add core2_32 \
		type=rpm-md\
		name="Jittertrap core2_32 Package Repository"\
		baseurl=http://testing.jittertrap.com/mousetrap/rpm/core2_32
}

ROOTFS_POSTPROCESS_COMMAND =+ "\
 postinst_enable_logging ;\
 set_root_password ;\
 add_custom_smart_config ;\
 ssh_allow_empty_password ;\
 rootfs_update_timestamp ;\
 ssh_disable_dns_lookup ;\
"

repository: acooks/meta-rationalist

repo_name: acooks/meta-rationalist


text:
# Copyright (C) 2018 蒼時弦也 <contact@frost.tw>
# Released under the MIT license (see COPYING.MIT for the terms)

LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=d4e6dcfaf544118f10b776fd45ecb52a"

PR = "r0"

BPV = "5.0.1"
PV = "${BPV}"
SRCREV = "b93bd80c3c8ac671c60760dd8a46d2a25ac860b8"

S = "${WORKDIR}/git"

SRC_URI = " \
    git://github.com/aasm/aasm.git \
    "

inherit rubygems

BBCLASSEXTEND = "native"

RDEPENDS_${PN} += " \
    concurrent-ruby \
"

repository: tamashii-io/meta-tamashii

repo_name: tamashii-io/meta-tamashii


text:
DESCRIPTION = "TPS php web interface"
HOMEPAGE = "http://tibbo.com/"
MAINTAINER = "Dmitry Dvorkin <dvorkin@tibbo.com>"
LICENSE = "LGPLv2+"

LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6"

inherit allarch systemd
require tps-www-user.inc

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

SRC_URI  = "file://*"

do_install() {
 install -d ${D}/var/www/tpsa-www/
 cp -rpf ${S}/* ${D}/var/www/tpsa-www/
 install -d ${D}${systemd_unitdir}/system
 install -m 0644 ${WORKDIR}/${PN}-${PR}/conf/php-fpm-tpsa.service ${D}${systemd_unitdir}/system
 chown -R ${WWW_U}:${WWW_G} ${D}/var/www/tpsa-www/
 # use `openssl passwd -apr1 123` to generate pass for webadmin
 # and save it to .htpasswd
}

FILES_${PN}  = "*"

DEPENDS += "tps-www-perms"
RDEPENDS_${PN} += "nginx php-fpm"

SYSTEMD_SERVICE_${PN} = "php-fpm-tpsa.service"
SYSTEMD_AUTO_ENABLE_php-fpm = "enable"


text:
require cherokee.inc

PR = "${INC_PR}.0"

SRC_URI = "http://www.cherokee-project.com/download/0.98/${PV}/cherokee-${PV}.tar.gz \
           file://cherokee.init "

CONFFILES_${PN} = " \
${sysconfdir}/cherokee/cherokee.conf \
${sysconfdir}/init.d/cherokee \
"

SRC_URI[md5sum] = "9f1876232bdfdfa5b4e02ff0636e7241"
SRC_URI[sha256sum] = "701721a58aa79b93a4f3aaf633f0b842a05b07c73996cd44e78a383a7387226d"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty