text:
package tls

import (
	"io/ioutil"
	"os"
	"path"
	"reflect"
	"testing"
)

func TestGetAll(t *testing.T) {
	m, stop := setup(t)
	defer stop()
	for _, t := range []string{
		"example2.com-2017-01-01-v000.json",
		"example.com-2017-01-01-v000.json",
		"example.com-2017-01-01-v001.json",
	} {
		p := path.Join(m.Config.DataPath(tlsDir, ""), t)
		_ = ioutil.WriteFile(p, []byte{}, os.ModePerm)
	}

	matches, err := m.GetAllRegisteredDomains()
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(matches, []string{"example.com", "example2.com"}) {
		t.Errorf("unexpected %s", matches)
	}
}

func TestCurrentTLSPath(t *testing.T) {
	m, stop := setup(t)
	defer stop()
	s, err := m.getCurrentRegistrationPath(testDomain)
	if err != nil {
		t.Errorf("unexpected error %v", err)
	}
	if s != "" {
		t.Errorf("unexpected string %s", s)
	}

	p1 := path.Join(m.Config.DataPath(tlsDir, ""), testPath)
	err = ioutil.WriteFile(p1, []byte{}, os.ModePerm)
	if err != nil {
		t.Fatal(err)
	}
	s, err = m.getCurrentRegistrationPath(testDomain)
	if err != nil {
		t.Errorf("unexpected error %v", err)
	}
	if path.Base(s) != testPath {
		t.Errorf("unexpected string %s", s)
	}

	// should ignore this
	p2 := path.Join(m.Config.DataPath(tlsDir, ""), testDomain+".json")
	err = ioutil.WriteFile(p2, []byte{}, os.ModePerm)
	if err != nil {
		t.Fatal(err)
	}
	s, err = m.getCurrentRegistrationPath(testDomain)
	if err != nil {
		t.Errorf("unexpected error %v", err)
	}
	if path.Base(s) != testPath {
		t.Errorf("unexpected string %s", s)
	}
}

func TestNextTLSPath(t *testing.T) {
	e1 := "example.com-2017-01-01-v000.json"
	e2 := "example.com-2017-01-01-v001.json"
	m, stop := setup(t)
	defer stop()
	s, err := m.getNextRegistrationPath(testDomain)
	if err != nil {
		t.Fatal(err)
	}
	if path.Base(s) != e1 {
		t.Errorf("unexpected next path: %s", path.Base(s))
	}

	err = ioutil.WriteFile(s, []byte{}, os.ModePerm)
	if err != nil {
		t.Fatal(err)
	}

	s, err = m.getNextRegistrationPath(testDomain)
	if err != nil {
		t.Fatal(err)
	}
	if path.Base(s) != e2 {
		t.Errorf("unexpected next path: %s", path.Base(s))
	}
}


text:
package apilxd

import (
	"fmt"
	"net/http"
	"time"
	"encoding/json"
	"database/sql"
	"math/rand"
	"errors"
	"strconv"
)

const PLANNER_RANDOM_STATE string = "random"
const PLANNER_GATHER_STATE string = "gather"
const PLANNER_SCATTER_STATE string = "scatter"

type Planner struct {
	db 	*sql.DB
}

func (planner * Planner) State() string {
	state,_ := getPlannerStateDB(planner.db)

	return state
}

func (planner * Planner) HostToDeploy() (string,error) {
	state := planner.State()
	containersInfo,err := getContainersHostInfoDB(planner.db)
	if err != nil {
		return "",err
	}
	switch state {
	case PLANNER_GATHER_STATE:
		fmt.Println("Gather strategy")
		hostname,err := calculateGatherStrategy(containersInfo)
		if err != nil {
			return "",err
		}
		return hostname,nil

	case PLANNER_SCATTER_STATE:
		fmt.Println("Scatter strategy")
		hostname,err := calculateScatterStrategy(containersInfo)
		if err != nil {
			return "",err
		}
		return hostname,nil

	case PLANNER_RANDOM_STATE:
		return calculateRandomStrategy(containersInfo),nil

	default:
		return "",errors.New("Strategy not set.")
	}
	return "",errors.New("Strategy not implemented.")
}
func calculateGatherStrategy(info [][]interface{}) (string,error) {
	score := make([]float64,len(info))
	for i := 0; i < len(info); i++ {
		memory,err := doGetAvailableMemory(info[i][1].(string))
		if err != nil {
			return "",err
		}
		cores,err := doGetCores(info[i][1].(string))
		if err != nil {
			return "",err
		}
		containernumber,err := strconv.ParseInt(info[i][2].(string),10,0)
		if err != nil {
			return "",err
		}
		score[i] = float64(memory/int(containernumber))
		score[i] = score[i] + score[i]*(float64(cores/int(containernumber)))
	}
	hostIndex := findMinIndex(score)
	hostname := info[hostIndex][1].(string)
	fmt.Printf("Selecting host %v with score %v",hostname,score[hostIndex])
	return hostname,nil
}

func calculateScatterStrategy(info [][]interface{}) (string,error) {
	score := make([]float64,len(info))
	for i := 0; i < len(info); i++ {
		memory,err := doGetAvailableMemory(info[i][1].(string))
		if err != nil {
			return "",err
		}
		cores,err := doGetCores(info[i][1].(string))
		if err != nil {
			return "",err
		}
		containernumber,err := strconv.ParseInt(info[i][2].(string),10,0)
		if err != nil {
			return "",err
		}
		score[i] = float64(memory/int(containernumber))
		score[i] = score[i] + score[i]*(float64(cores/int(containernumber)))
	}
	hostIndex := findMaxIndex(score)
	hostname := info[hostIndex][1].(string)
	fmt.Printf("Selecting host %v with score %v",hostname,score[hostIndex])
	return hostname,nil
}

func calculateRandomStrategy(info [][]interface{}) string {
	rand.Seed(time.Now().Unix())
	randomInt := rand.Intn(len(info))
	hostname := info[randomInt][1].(string)
	fmt.Printf("Selecting host %v",hostname,"with random id %v",randomInt)
	return hostname
}
var plannerCmd = Command{
	name: "planner",
	get:  plannerGet,
	post: plannerPost,
	put: plannerPut,
}
func plannerGet(lx *LxdpmApi,  r *http.Request) Response {
	state,err := getPlannerStateDB(lx.db)
	if err != nil {
		return BadRequest(err)
	}
	return SyncResponse(true,state)
}

type PlannerPost struct {

	State   string          `json:"state" yaml:"state"`
}

func plannerPost(lx *LxdpmApi,  r *http.Request) Response {
	req := PlannerPost{}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		return BadRequest(err)
	}

	err := putPlannerDB(lx,req.State,time.Now())
	if err != nil {
		return BadRequest(err)
	}
	return SyncResponse(true,"")
}

func plannerPut(lx *LxdpmApi,  r *http.Request) Response {
	req := PlannerPost{}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		return BadRequest(err)
	}

	err := updatePlannerDB(lx,req.State,time.Now())
	if err != nil {
		return BadRequest(err)
	}
	return SyncResponse(true,"")
}

func getContainersHostInfoDB(db *sql.DB) ([][]interface{},error) {
	inargs := []interface{}{}
	outargs := []interface{}{"id","name","container_number"}
	//cash, err := lx.db.Query(`SELECT * FROM hosts`)
	result, err := dbQueryScan(db, `SELECT H.id,H.name,count(*) as container_number FROM hosts H LEFT JOIN containers C ON ( H.id = C.host_id ) GROUP BY H.id,H.name`,inargs,outargs )
	if err != nil {
		fmt.Println(err)
		return nil,err
	}
	if len(result) == 0 {
		return nil , nil
	}

	return result,nil
}

func getPlannerStateDB(db *sql.DB) (string,error) {
	inargs := []interface{}{}
	outargs := []interface{}{"state"}
	//cash, err := lx.db.Query(`SELECT * FROM hosts`)
	result, err := dbQueryScan(db, `SELECT state FROM planner`,inargs,outargs )
	if err != nil {
		fmt.Println(err)
		return "",err
	}
	if len(result) == 0 {
		return "" , nil
	}

	return result[0][0].(string) ,nil
}

func putPlannerDB(lx *LxdpmApi,state string,timestamp time.Time) error{
	q := `INSERT INTO planner (state,updated_at) VALUES (?,?)`
	_,err := dbExec(lx.db,q,state,timestamp.Format(time.RFC3339))
	return err
}

func updatePlannerDB(lx *LxdpmApi,state string,timestamp time.Time) error{
	q := `UPDATE planner SET state=?,updated_at=? WHERE id=1;`
	_,err := dbExec(lx.db,q,state,timestamp.Format(time.RFC3339))
	return err
}

func findMaxIndex(array []float64) int {
	var max float64 = 0.0
	var index int
	for i := 0; i < len(array); i++ {
		if array[i] > max {
			max = array[i]
			index = i
		}
	}
	return index
}

func findMinIndex(array []float64) int {
	var min float64 = 10000000000000000000000000.0
	var index int
	for i := 0; i < len(array); i++ {
		if array[i] < min {
			min = array[i]
			index = i
		}
	}
	return index
}

repository: simhaonline/lxdpm

license_type: permissive

repo_name: simhaonline/lxdpm

branch_name: refs/heads/master

extension: go


text:
const spawn = require('cross-spawn')

module.exports = {
  description: 'Scaffolding out a go lang rpc module.',
  prompts() {
    return [
      {
        name: 'name',
        message: 'What is the name of the new project?',
        default: this.outFolder
      },
      {
        name: 'description',
        message: 'How would you descripe the new project?',
        default: `my go grpc project`
      },
      {
        name: 'author',
        message: 'What is your name',
        default: this.gitUser.name,
        store: true,
        required: true
      },
      {
        name: 'username',
        message: 'What is your GitHub username',
        default: this.gitUser.name,
        store: true,
        required: true
      },
      {
        name: 'email',
        message: 'What is your GitHub email',
        default: this.gitUser.email,
        store: true,
        required: true,
        validate: v => /.+@.+/.test(v)
      },
      {
        name: 'projectPath',
        message: 'Set your project path: ',
        required: true,
        // required
        validate: v => v !== ''
      },
      {
        name: 'website',
        default({ username }) {
          return `https://github.com/${username}`
        },
        store: true
      },
      {
        name: 'test',
        message: 'Use a ci?',
        type: 'confirm',
        default: true
      },
      {
        name: 'gateway',
        message: 'With grpc gateway?',
        type: 'confirm',
        default: true
      }
    ]
  },
  actions() {
    return [
      {
        type: 'add',
        files: '**',
        filters: {
          'circle.yml': 'test',
          'pb/pb.pb.gw.go': 'gateway',
          'pb/pb.swagger.json': 'gateway'
        }
      },
      {
        type: 'move',
        patterns: {
          // We keep `.gitignore` as `gitignore` in the project
          // Because when it's published to npm
          // `.gitignore` file will be ignored!
          gitignore: '.gitignore',
        }
      }
    ]
  },
  async completed() {
    spawn.sync('chmod', ['+x', './build.sh'], {
      stdio: 'ignore',
      cwd: this.outDir
    })
    this.gitInit()
    this.showProjectTips()
  }
}

license: MIT

extension: js


text:
@article{ballouz2017,
  author = {Ballouz, Sara and Weber, Melanie and Pavlidis, Paul and Gillis, Jesse},
  title = {EGAD: ultra-fast functional analysis of gene networks},
  journal = {Bioinformatics},
  volume = {33},
  number = {4},
  pages = {612–614},
  note = {10.1093/bioinformatics/btw695},
  year = {2017}
}

@article{zeisel15,
  author = {Zeisel, Amit and Muñoz-Manchado, Ana B. and Codeluppi, Simone and Lönnerberg, Peter and La Manno, Gioele and Juréus, Anna and Marques, Sueli and Munguba, Hermany and He, Liqun and Betsholtz, Christer and Rolny, Charlotte and Castelo-Branco, Gonçalo and Hjerling-Leffler, Jens and Linnarsson, Sten},
  title = {Cell types in the mouse cortex and hippocampus revealed by single-cell RNA-seq},
  journal = {Science},
  volume = {347},
  number = {6226},
  pages = {1138-1142},
  note = {10.1126/science.aaa1934},
  year = {2015}
}

@article{Tasic16,
  author = {Tasic, Bosiljka and Menon, Vilas and Nghi Nguyen, Thuc and Kyung Kim,  Tae and Jarsky, Tim and Yao, Zizhen and Levi, Boaz and T Gray, Lucas and A Sorensen, Staci and Dolbeare, Tim and Bertagnolli, Darren and Goldy, Jeff and Shapovalova, Nadiya and Parry, Sheana and Lee, Changkyu and Smith, Kimberly and Bernard, Amy and Madisen, Linda and M Sunkin, Susan and Hawrylycz, Michael and Koch, Christof and Zeng, Hongkui},
  title = {Adult mouse cortical cell taxonomy revealed by single cell transcriptomics},
  journal = {NATURE NEUROSCIENCE},
  volume = {19},
  number = {2},
  pages = {335–346},
  note = {doi:10.1038/nn.4216},
  year = {2016}
}

repository: gillislab/MetaNeighbor

repo_name: gillislab/MetaNeighbor

gha_license_id: MIT

gha_language: R

extension: bib


text:
package codelab

import (
	"errors"
	"log"

	tf "github.com/tensorflow/tensorflow/tensorflow/go"
)

// GetInputShape finds the input image dimensions.
func GetInputShape(graph *tf.Graph) (width, height int) {
	input := graph.Operation("module/hub_input/images")
	if input == nil {
		log.Fatal("Cannot find tensor \"module/hub_input/images\"")
	}
	shape := input.Output(0).Shape()
	return int(shape.Size(1)), int(shape.Size(2))
}

// RunInference executes the model and returns the logits.
func RunInference(graph *tf.Graph, session *tf.Session, image [][][3]float32) ([]float32, error) {
	inputOp := graph.Operation("module/hub_input/images")
	if inputOp == nil {
		return nil, errors.New("Cannot find tensor \"module/hub_input/images\"")
	}
	input := inputOp.Output(0)
	outputOp := graph.Operation("module/MobilenetV2/Logits/output")
	if outputOp == nil {
		return nil, errors.New("Cannot find tensor \"module/MobilenetV2/Logits/output\"")
	}
	output := outputOp.Output(0)
	images, err := tf.NewTensor([][][][3]float32{image})
	if err != nil {
		return nil, err
	}
	result, err := session.Run(
		map[tf.Output]*tf.Tensor{input: images}, []tf.Output{output}, nil)
	if err != nil {
		return nil, err
	}
	return result[0].Value().([][]float32)[0], nil
}

repository: src-d/tensorflow-codelab

repo_name: src-d/tensorflow-codelab


text:
@article{kang2020review,
 abstract = {Urban physical environments are the physical settings and built environments in neighbourhoods and cities which provide places for human activities. Evidence suggests that there are substantial associations between urban physical environments and various health outcomes, e.g. people's physical activities might be influenced by surrounding physical environments, thereby affecting their health behaviours; more exposure to urban physical environments may benefit human mental health. Street view imagery enables us to capture the landscape at eye-level, making it a promising data source for observing and analysing the realistic dynamics of urban physical environments. Compared with traditional in-person assessments and field observations, street view imagery-based data collection is relatively time-effective and cost-effective. Researchers from epidemiology, psychology, and geography have used street view imagery to quantify the built environment and understand its impacts on public health. To summarize current research trends, this paper systematically reviews the use of street view images for sensing urban environments in public health studies. Specifically, we describe the characteristics of street view imagery and review the methodology for image processing and semantic understanding. We then summarize the challenges that remain for quantifying urban environments in terms of data and methodology. Several future research directions that would benefit public health research and practices are recommended in urban environment research.},
 annotation = {00017  _eprint: https://doi.org/10.1080/19475683.2020.1791954},
 author = {Kang, Yuhao and Zhang, Fan and Gao, Song and Lin, Hui and Liu, Yu},
 doi = {10.1080/19475683.2020.1791954},
 file = {/Users/baoyi/Zotero/storage/NLIPA7H8/Kang 等。 - 2020 - A review of urban physical environment sensing usi.pdf;/Users/baoyi/Zotero/storage/D37JA3SE/19475683.2020.html},
 issn = {1947-5683},
 journal = {Annals of GIS},
 keywords = {public health,Street view imagery,urban environment},
 month = {July},
 number = {3},
 pages = {261--275},
 publisher = {Taylor & Francis},
 title = {A Review of Urban Physical Environment Sensing Using Street View Imagery in Public Health Studies},
 volume = {26},
 year = {2020}
}

branch_name: refs/heads/main


text:
SECTION = "devel"
DEPENDS = "elfutils "
DESCRIPTION = " The prelink package contains a utility which modifies ELF shared libraries \
and executables, so that far fewer relocations need to be resolved at \
runtime and thus programs come up faster."
LICENSE = "PRELINK"
SRC_URI = "${DEBIAN_MIRROR}/main/p/prelink/prelink_0.0.${PV}.orig.tar.gz \
           file://prelink.conf \
           file://prelink.cron.daily \
           file://prelink.default"
S = "${WORKDIR}/prelink-0.0.${PV}"

inherit autotools

do_install_append () {
	install -d ${D}${sysconfdir}/cron.daily ${D}${sysconfdir}/default
	install -m 0644 ${WORKDIR}/prelink.conf ${D}${sysconfdir}/prelink.conf
	install -m 0644 ${WORKDIR}/prelink.cron.daily ${D}${sysconfdir}/cron.daily/prelink
	install -m 0644 ${WORKDIR}/prelink.default ${D}${sysconfdir}/default/prelink
}

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux

extension: bb


text:
@article{wolf2019huggingfaces,
	Author = {Thomas Wolf and Lysandre Debut and Victor Sanh and Julien Chaumond and Clement Delangue and Anthony Moi and Pierric Cistac and Tim Rault and R'emi Louf and Morgan Funtowicz and Jamie Brew},
	Date-Added = {2020-07-28 23:52:37 -0400},
	Date-Modified = {2020-07-28 23:52:38 -0400},
	Journal = {ArXiv},
	Title = {HuggingFace's Transformers: State-of-the-art Natural Language Processing},
	Volume = {abs/1910.03771},
	Year = {2019},
  urldate = {2020-05-15}}

@phdthesis{altosaar2020probabilistic,
	Author = {Altosaar, Jaan},
	Date-Added = {2020-06-01 05:47:28 -0400},
	Date-Modified = {2020-06-01 05:47:57 -0400},
	School = {Princeton University},
	Title = {Probabilistic Modeling of Structure in Science: Statistical Physics to Recommender Systems},
	Year = {2020},
  urldate = {2020-05-05}}

@inproceedings{devlin2019bert:,
	Abstract = {We introduce a new language representation model called BERT, which stands for Bidirectional Encoder Representations from Transformers. Unlike recent language representation models (Peters et al., 2018a; Radford et al., 2018), BERT is designed to pre-train deep bidirectional representations from unlabeled text by jointly conditioning on both left and right context in all layers. As a result, the pre-trained BERT model can be fine-tuned with just one additional output layer to create state-of-the-art models for a wide range of tasks, such as question answering and language inference, without substantial task-specific architecture modifications. BERT is conceptually simple and empirically powerful. It obtains new state-of-the-art results on eleven natural language processing tasks, including pushing the GLUE score to 80.5 (7.7 point absolute improvement), MultiNLI accuracy to 86.7{\%} (4.6{\%} absolute improvement), SQuAD v1.1 question answering Test F1 to 93.2 (1.5 point absolute improvement) and SQuAD v2.0 Test F1 to 83.1 (5.1 point absolute improvement).},
	Address = {Minneapolis, Minnesota},
	Author = {Devlin, Jacob and Chang, Ming-Wei and Lee, Kenton and Toutanova, Kristina},
	Booktitle = {Association for Computational Linguistics},
	Date-Added = {2020-06-01 05:15:02 -0400},
	Date-Modified = {2020-06-01 05:15:02 -0400},
	Doi = {10.18653/v1/N19-1423},
	Month = jun,
	Pages = {4171--4186},
	Publisher = {Association for Computational Linguistics},
	Title = {{BERT}: Pre-training of Deep Bidirectional Transformers for Language Understanding},
	Url = {https://www.aclweb.org/anthology/N19-1423},
	Year = {2019},
  urldate = {2020-05-10}}

@article{altosaar2020rankfromsets:,
	Author = {Altosaar, Jaan and Tansey, Wesley and Ranganath, Rajesh},
	Date-Added = {2020-06-01 03:20:09 -0400},
	Date-Modified = {2020-06-01 03:20:10 -0400},
	Journal = {American Statistical Association Symposium on Data Science \& Statistics},
	Title = {{RankFromSets}: Scalable Set Recommendation with Optimal Recall},
	Year = {2020},
  urldate = {2020-05-24}}

@article{tieleman2012lecture,
	Abstract = {Tieleman, Tijmen and Hinton, Geoffrey. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 4, 2012},
	Author = {Tieleman, Tijmen and Hinton, Geoffrey},
	Date-Added = {2016-05-13 19:14:56 +0000},
	Date-Modified = {2019-01-29 15:30:10 -0500},
	Journal = {COURSERA: Neural Networks for Machine Learning},
	Title = {{Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.}},
	Year = {2012},
  urldate = {2020-06-02}}

@article{nlpfundamentals,
	title={Natural language processing: an introduction},
	url={https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3168328/},
	journal={Journal of the American Medical Informatics Association : JAMIA},
	publisher={BMJ Group},
	author={Nadkarni, Prakash M and Ohno-Machado, Lucila and Chapman, Wendy W},
	year={2011},
  urldate = {2020-08-25}}

@article {transformers:,
  author = {Ashish Vaswani and
               Noam Shazeer and
               Niki Parmar and
               Jakob Uszkoreit and
               Llion Jones and
               Aidan N. Gomez and
               Lukasz Kaiser and
               Illia Polosukhin},
  title = {Attention Is All You Need},
  journal = {CoRR},
  volume = {abs / 1706.03762},
  year = {2017},
  url = {http://arxiv.org/abs/1706.03762},
  archivePrefix = {arXiv},
  eprint = {1706.03762},
  timestamp = {Mon, 13 Aug 2018 16:48:37 +0200},
  biburl = {https://dblp.org/rec/journals/corr/VaswaniSPUJGKP17.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org},
  urldate = {2020-05-27}
}

@book{harris_harris_2015, place={Waltham, Mass}, title={Digital design and computer architecture}, publisher={Morgan Kaufmann}, author={Harris, David Money and Harris, Sarah L.}, year={2015},
urldate = {2020-09-14}}

@article{king_man_woman_queen,
Author={Allen, Carl and Hospedales, Timothy},
title={King - man + woman = queen: the hidden algebraic structure of words}, url={https://www.ed.ac.uk/informatics/news-events/stories/2019/king-man-woman-queen-the-hidden-algebraic-struct}, journal={The University of Edinburgh}, year={2019}, month={Jul}, urldate = {2020-10-12}}

@book{svetoslav_2015, place={Place of publication not identified}, title={Sigmoid Functions: Some Approximation and Modelling Aspects}, publisher={Lap Lambert Academic Publishing}, author={Svetoslav, Markov and Kyurkchiev, Nikoley}, year={2015}, urldate = {2020-09-18}}

@misc{olah_2015, title={Understanding LSTM Networks}, url={https://colah.github.io/posts/2015-08-Understanding-LSTMs/}, journal={Colah's Blog}, author={Olah, Christopher}, year={2015}, month={Aug}, urldate = {2020-06-22}}

@article{hochreiter1997long,
  title={Long short-term memory},
  author={Hochreiter, Sepp and Schmidhuber, J{\"u}rgen},
  journal={Neural computation},
  volume={9},
  number={8},
  pages={1735--1780},
  year={1997},
  publisher={MIT Press},
  urldate = {2020-06-22}
}

@misc{alammar_2018, title={The Illustrated Transformer}, url={http://jalammar.github.io/illustrated-transformer/}, journal={Visualizing machine learning one concept at a time.}, author={Alammar, Jay}, year={2018}, month={Jun}, urldate = {2020-05-15}}

@misc{karim_2019, title={Illustrated: Self-Attention}, url={https://towardsdatascience.com/illustrated-self-attention-2d627e33b20a}, journal={Medium}, publisher={Towards Data Science}, author={Karim, Raimi}, year={2019}, month={Dec}, urldate = {2020-05-14}}

@book{bengio_goodfellow_courville_2017, place={Massachusetts}, title={Deep learning}, publisher={MIT Press}, author={Bengio, Yoshua and Goodfellow, Ian and Courville, Aaron}, year={2017}, urldate = {2020-09-23}}

@misc{alammar_2019, title={A Visual Guide to Using BERT for the First Time}, url={http://jalammar.github.io/a-visual-guide-to-using-bert-for-the-first-time/}, journal={Visualizing machine learning one concept at a time.}, author={Alammar, Jay}, year={2019}, month={Nov}, urldate = {2020-05-14}}

@article{domingos2012few,
  title={A few useful things to know about machine learning},
  author={Domingos, Pedro},
  journal={Communications of the ACM},
  volume={55},
  number={10},
  pages={78--87},
  year={2012},
  publisher={ACM New York, NY, USA},
  urldate = {2020-06-28},
}

@misc{gonzlezcarvajal2020comparing,
    title={Comparing BERT against traditional machine learning text classification},
    author={Santiago González-Carvajal and Eduardo C. Garrido-Merchán},
    year={2020},
    eprint={2005.13012},
    archivePrefix={arXiv},
    primaryClass={cs.CL},
    urldate = {2020-08-26}
}

@article{lecun2015deep,
  title={Deep learning},
  author={LeCun, Yann and Bengio, Yoshua and Hinton, Geoffrey},
  journal={nature},
  volume={521},
  number={7553},
  pages={436--444},
  year={2015},
  publisher={Nature Publishing Group},
  urldate = {2020-09-23}
}

@misc{sun2019finetune,
    title={How to Fine-Tune BERT for Text Classification?},
    author={Chi Sun and Xipeng Qiu and Yige Xu and Xuanjing Huang},
    year={2019},
    eprint={1905.05583},
    archivePrefix={arXiv},
    primaryClass={cs.CL},
    urldate = {2020-05-15}
}

@incollection{NEURIPS2019_9015,
title = {PyTorch: An Imperative Style, High-Performance Deep Learning Library},
author = {Paszke, Adam and Gross, Sam and Massa, Francisco and Lerer, Adam and Bradbury, James and Chanan, Gregory and Killeen, Trevor and Lin, Zeming and Gimelshein, Natalia and Antiga, Luca and Desmaison, Alban and Kopf, Andreas and Yang, Edward and DeVito, Zachary and Raison, Martin and Tejani, Alykhan and Chilamkurthy, Sasank and Steiner, Benoit and Fang, Lu and Bai, Junjie and Chintala, Soumith},
booktitle = {Advances in Neural Information Processing Systems 32},
editor = {H. Wallach and H. Larochelle and A. Beygelzimer and F. d\textquotesingle Alch\'{e}-Buc and E. Fox and R. Garnett},
pages = {8024--8035},
year = {2019},
publisher = {Curran Associates, Inc.},
url = {http://papers.neurips.cc/paper/9015-pytorch-an-imperative-style-high-performance-deep-learning-library.pdf},
urldate = {2020-07-25}
}

@book{bellman_1954, title={The Theory of Dynamic Programming}, publisher={Defense Technical Information Center}, author={Bellman, Richard}, year={1954}, urldate = {2020-10-13}}

@misc{dot_products_2008, url={https://nlp.stanford.edu/IR-book/html/htmledition/dot-products-1.html}, journal={Dot products}, publisher={Cambridge University Press}, year={2008}, urldate = {2020-11-07}}


text:
DESCRIPTION = "Packages that are compatible with the OpenSlug firmware"
LICENSE = MIT
PR = "r3"

INHIBIT_DEFAULT_DEPS = "1"
ALLOW_EMPTY = 1
PACKAGES = "${PN}"

OPENSLUG_DEVELOPMENT = "\
	autoconf \
	automake \
	bash \
	binutils \
	bison \
	bzip2 \
	coreutils \
	cvs \
	diffutils \
	diffstat \
	findutils \
	flex \
	gawk \
	gcc \
	gdb \
	gnu-config \
	grep \
	ipkg-utils \
	lsof \
	m4 \
	make \
	monotone-4 monotone-5 \
	ncurses \
	openssh \
	patch \
	pciutils \
	pkgconfig \
	quilt \
	sed \
	util-linux \
	"

# These packages only build on TARGET_OS=linux, not
# TARGET_OS=linux-uclibc
OPENSLUG_DEVELOPMENT_append_linux = "\
	perl \
	tar \
	"

OPENSLUG_PACKAGES = "\
	bash \
	bluez-utils-nodbus \
	bridge-utils \
	bwmon \
	coreutils \
	cron \
	cvs\
	dnsmasq \
	expat \
	ftpd-topfield \
	glib-2.0 \
	gphoto2 \
	gtk-doc \
	gzip \
	joe \
	less \
	libusb \
	libxml2 \
	miau \
	microcom \
	mt-daapd \
	mutt \
	mysql \
	nail \
	openssh \
	openvpn \
	pcre \
	ppp \
	puppy \
	pwc \
	rsync \
	sudo \
	screen \
	sysfsutils \
	thttpd \
	timezones \
	db4 \
	openldap \
	openntpd \
	openssh \
	ntp \
	reiserfsprogs reiser4progs \
	procps \
	psmisc \
	python \
	samba \
	sane-backends \
	strace \
	thttpd \
	vlan \
	wakelan \
	wget \
	unionfs-modules unionfs-utils \
	zlib \
	"

# These packages only build on TARGET_OS=linux, not
# TARGET_OS=linux-uclibc  (Note that for several this
# is because of use of single precision FP interfaces
# such as sinf.)
OPENSLUG_PACKAGES_append_linux = "\
	bind \
	mgetty \
	mpd \
	nfs-utils \
	libpam \
	php \
	xinetd \
	yp-tools ypbind ypserv \
	"

BROKEN_PACKAGES = "\
	atftp \
	postfix \
	"

DEPENDS = 'openslug-image \
	${OPENSLUG_PACKAGES} \
	${OPENSLUG_DEVELOPMENT} \
	openslug-native \
	package-index'

repository: BackupTheBerlios/openslug-svn

repo_name: BackupTheBerlios/openslug-svn


text:
@article{orife_masakhane_2020,
	title = {Masakhane -- Machine Translation For Africa},
	url = {http://arxiv.org/abs/2003.11529},
	abstract = {Africa has over 2000 languages. Despite this, African languages account for a small portion of available resources and publications in Natural Language Processing ({NLP}). This is due to multiple factors, including: a lack of focus from government and funding, discoverability, a lack of community, sheer language complexity, difficulty in reproducing papers and no benchmarks to compare techniques. To begin to address the identified problems, {MASAKHANE}, an open-source, continent-wide, distributed, online research effort for machine translation for African languages, was founded. In this paper, we discuss our methodology for building the community and spurring research from the African continent, as well as outline the success of the community in terms of addressing the identified problems affecting African {NLP}.},
	journaltitle = {{arXiv}:2003.11529 [cs]},
	author = {Orife, Iroro and Kreutzer, Julia and Sibanda, Blessing and Whitenack, Daniel and Siminyu, Kathleen and Martinus, Laura and Ali, Jamiil Toure and Abbott, Jade and Marivate, Vukosi and Kabongo, Salomon and Meressa, Musie and Murhabazi, Espoir and Ahia, Orevaoghene and van Biljon, Elan and Ramkilowan, Arshath and Akinfaderin, Adewale and Öktem, Alp and Akin, Wole and Kioko, Ghollah and Degila, Kevin and Kamper, Herman and Dossou, Bonaventure and Emezue, Chris and Ogueji, Kelechi and Bashir, Abdallah},
	urldate = {2020-06-24},
	date = {2020-03-13},
	eprinttype = {arxiv},
	eprint = {2003.11529},
	keywords = {Computer Science - Computation and Language},
	file = {arXiv Fulltext PDF:/home/abdallah/Zotero/storage/IDYLDLA6/Orife et al. - 2020 - Masakhane -- Machine Translation For Africa.pdf:application/pdf;arXiv.org Snapshot:/home/abdallah/Zotero/storage/6YCJA5UV/2003.html:text/html}
}

filename: Exported Items.bib


text:
@InProceedings{kamishima:icdmw:2013,
  author    = {Kamishima, Toshihiro and Akaho, Shotaro and Asoh, Hideki and Sakuma, Jun},
  title     = {The Independence of the Fairness-aware Classifier},
  booktitle = {IEEE International Conference on Data Mining Workshops},
  year      = {2013},
  address   = {Dallas (TX), USA},
  month     = {December 7-December 10},
  url       = {https://www.kamishima.net/archive/2013-ws-icdm-HN.pdf},
  keywords  = {Data mining, Standards, Predictive models, Indexes, Data models, Privacy. Employment},
  doi       = {10.1109/ICDMW.2013.133},
  abstract  = {Due to the spread of data mining technologies, such technologies are being used for determinations that seriously affect individuals\textquotesingle  lives. For example, credit scoring is frequently determined based on the records of past credit data together with statistical prediction techniques. Needless to say, such determinations must be nondiscriminatory and fair in sensitive features, such as race, gender, religion, and so on. The goal of fairness-aware classifiers is to classify data while taking into account the potential issues of fairness, discrimination, neutrality, and/or independence. In this paper, after reviewing fairness-aware classification methods, we focus on one such method, Calders and Verwer\textquotesingle s two-naive-Bayes method. This method has been shown superior to the other classifiers in terms of fairness, which is formalized as the statistical independence between a class and a sensitive feature. However, the cause of the superiority is unclear, because it utilizes a somewhat heuristic post-processing technique rather than an explicitly formalized model. We clarify the cause by comparing this method with an alternative naive Bayes classifier, which is modified by a modeling technique called "hypothetical fair-factorization." This investigation reveals the theoretical background of the two-naive-Bayes method and its connections with other methods. Based on these findings, we develop another naive Bayes method with an "actual fair-factorization technique" and empirically show that this new method can achieve an equal level of fairness as that of the two-naive-Bayes classifier.}
}

gha_language: TeX


text:
// Copyright (c) 2018 Hervé Gouchet. All rights reserved.
// Use of this source code is governed by the MIT License
// that can be found in the LICENSE file.

package bolt_test

import (
	"io/ioutil"
	"testing"

	"github.com/rvflash/safe"
	"github.com/rvflash/safe/bolt"
)

func newDB() (safe.Service, error) {
	path, err := ioutil.TempDir("", "safe")
	if err != nil {
		return nil, err
	}
	return bolt.Open(path, "test")

}

func TestSafe_CreateOwner(t *testing.T) {
	// Opens temporary DB
	db, err := newDB()
	if err != nil {
		t.Fatalf("workspace: %s", err)
	}
	defer func() {
		if err = db.Close(); err != nil {
			t.Fatalf("db closing: %s", err)
		}
	}()
	// Sort order matters in this tests suite.
	var dt = []struct {
		in                *safe.Passphrase
		hasOwner, isOwner bool
		err               error
	}{
		{in: safe.NewPassPhrase("tooShort"), err: safe.ErrInvalid},
		{in: safe.NewPassPhrase("minimumLength:16"), hasOwner: true, isOwner: true},
		{in: safe.NewPassPhrase("minimumLength-16"), err: safe.ErrInvalid, hasOwner: true, isOwner: false},
	}
	var ok bool
	for i, tt := range dt {
		err = db.CreateOwner(tt.in)
		if err != tt.err {
			t.Errorf("%d. mismatch error: got=%q exp=%q", i, err, tt.err)
		}
		if ok = db.HasOwner(); ok != tt.hasOwner {
			t.Errorf("%d. unexpected result: got=%t exp=%t", i, ok, tt.hasOwner)
		}
		if ok = db.IsOwner(tt.in); ok != tt.isOwner {
			t.Errorf("%d. unexpected owner: got=%t exp=%t", i, ok, tt.isOwner)
		}
	}
}

repository: rvflash/safe

repo_name: rvflash/safe


text:
# By default, use embedded version of gtest:
set(CMAKE_MRPT_HAS_GTEST         1)
set(CMAKE_MRPT_HAS_GTEST_SYSTEM  0)
set(CMAKE_MRPT_GTEST_SRC_DIR     "${MRPT_SOURCE_DIR}/3rdparty/gtest-1.10.0")

repository: DEVESHTARASIA/mrpt

repo_name: DEVESHTARASIA/mrpt

branch_name: refs/heads/develop

extension: cmake


text:
@article{Baulch-2019-Soil,
    title = "Soil and water management: opportunities to mitigate nutrient losses to surface waters in the Northern Great Plains",
    author = "Baulch, Helen M.  and
      Elliott, Jane A.  and
      Cordeiro, Marcos R.C.  and
      Flaten, Don N.  and
      Lobb, David A.  and
      Wilson, Henry F.",
    journal = "Environmental Reviews, Volume 27, Issue 4",
    volume = "27",
    number = "4",
    year = "2019",
    publisher = "Canadian Science Publishing",
    url = "https://aclanthology.org/G19-28001",
    doi = "10.1139/er-2018-0101",
    pages = "447--477",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

gha_language: Python


text:
# ------------------------------------------------------------------------------------------------ #
#                                                                                #
#     _)  |  |            _)                This code may be used and modified under the terms     #
#      |  |  |  |  | (_-<  |   _ \    \     of the MIT license. See the LICENSE file for details.  #
#     _| _| _| \_,_| ___/ _| \___/ _| _|    Copyright (c) 2018-2019 Simon Schneegans               #
#                                                                                #
# ------------------------------------------------------------------------------------------------ #

message("Configuring spirv-tools")

set(SPIRV-Headers_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/externals/spirv-headers)
set(SKIP_SPIRV_TOOLS_INSTALL ON)
set(SPIRV_SKIP_EXECUTABLES ON)
add_subdirectory(externals/spirv-tools)

message("")

repository: Schneegans/illusion

repo_name: Schneegans/illusion


text:
package userModel

import (
	"time"
)

// User model
type User struct {
	Id            string     `json:"id" bson:"_id,omitempty"`
	Email         *string    `json:"email" bson:"email,omitempty"`
	Locale        string     `json:"locale" bson:"locale,omitempty"`
	Password      string     `json:"password" bson:"password,omitempty"`
	PasswordRetry string     `json:"retryPassword" bson:"-"`
	RecoveryToken string     `json:"recoveryToken" bson:"-"`
	Gender        string     `json:"gender" bson:"-"`
	Profiles      []Profile  `json:"profiles" bson:"profiles,omitempty"`
	CreatedAt     *time.Time `json:"created_at" bson:"created_at,omitempty"`
	UpdatedAt     *time.Time `json:"updated_at" bson:"updated_at,omitempty"`
}

type Profile struct {
	Type    string `json:"type"`
	Id      string `json:"id"`
	Link    string `json:"link"`
	Name    string `json:"name"`
	Picture string `json:"picture"`
}

repository: micro-company/go-auth

repo_name: micro-company/go-auth

gha_language: Go


text:
DESCRIPTION = "DS emulator, sorta"

LICENSE = "GPL-3.0-or-later"
LIC_FILES_CHKSUM = "file://LICENSE;md5=d32239bcb673463ab874e80d47fae504"

SRC_URI = "gitsm://github.com/Arisotura/melonds.git;protocol=https;branch=master"
SRCREV = "0.9.2"
S = "${WORKDIR}/git"

inherit cmake_qt5

PACKAGECONFIG ?= "frontend jit"

PACKAGECONFIG[frontend] = "-DBUILD_QT_SDL=ON,-DBUILD_QT_SDL=OFF,libsdl2"
PACKAGECONFIG[jit] = "-DENABLE_JIT=ON,-DENABLE_JIT=OFF"
PACKAGECONFIG[lto] = "-DENABLE_LTO=ON,-DENABLE_LTO=OFF"

DEPENDS += "libarchive libepoxy libslipr"

gha_language: BitBake


text:
@book{brown2016,
	address = {Cambridge, [New York]},
	title = {The {Universal} {Declaration} of {Human} {Rights} in the 21st century, a living document in a changing world},
	isbn = {9781783742202},
	abstract = {"The Global Citizenship Commission was convened, under the leadership of former British Prime Minister Gordon Brown and the auspices of NYUђ́ةs Global Institute for Advanced Study, to re-examine the spirit and stirring words of The Universal Declaration of Human Rights. The result - this volume - offers a 21st-century commentary on the original document, furthering the work of human rights and illuminating the ideal of global citizenship. What does it mean for each of us to be members of a global communitySince 1948, the Declaration has stood as a beacon and a standard for a better world. Yet the work of making its ideals real is far from over. Hideous and systemic human rights abuses continue to be perpetrated at an alarming rate around the world. Too many people, particularly those in power, are hostile to human rights or indifferent to their claims. Meanwhile, our global interdependence deepens. Bringing together world leaders and thinkers in the fields of politics, ethics, and philosophy, the Commission set out to develop a common understanding of the meaning of global citizenship - one that arises from basic human rights and empowers every individual in the world. This landmark report affirms the Universal Declaration of Human Rights and seeks to renew the 1948 enterprise, and the very ideal of the human family, for our day and generation. Members of the Global Citizenship Commission include: K. Anthony Appiah, Laurel Bellows, Nicolas Berggruen, Paul Boghossian, Gordon Brown (Chair), Craig Calhoun, Wang Chenguang, Mohamed ElBaradei, Fonna Forman, Andrew Forrest, Ronald M. George, Asma Jahangir, John Kufuor, Gra©ʹa Machel, Catherine O'Regan, Ricken Patel, Emma Rothschild, Robert Rubin, Jonathan Sacks, Kailash Satyarthi, Klaus Schwab, Amartya Sen, John Sexton, Robert Shrum, Jeremy Waldron, Joseph Weiler, Rowan Williams, Diane C. Yu (Executive Director)."-- Provided by publisher},
	language = {eng},
	publisher = {Open Book Publishers ; NYU Global Institute for Advanced Study},
	editor = {Brown, Gordon},
	year = {2016},
	note = {OCLC: 946613621},
}

repository: maehr/academic-pandoc-template

repo_name: maehr/academic-pandoc-template

gha_language: HTML


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

package antlr

import (
	"strconv"
	"strings"
	"unicode/utf8"
)

func unquoteString(s string) (string, error) {
	n := len(s)
	if n < 2 {
		return "", strconv.ErrSyntax
	}
	quote := s[0]
	if quote != s[n-1] {
		return "", strconv.ErrSyntax
	}
	s = s[1 : n-1]

	if quote != '"' && quote != '\'' {
		return "", strconv.ErrSyntax
	}

	if !contains(s, '\\') && !contains(s, quote) && utf8.ValidString(s) {
		return s, nil
	}

	var runeTmp [utf8.UTFMax]byte
	buf := make([]byte, 0, 3*len(s)/2)
	for len(s) > 0 {
		c, multibyte, ss, err := strconv.UnquoteChar(s, quote)
		if err != nil {
			return "", err
		}
		s = ss
		if c < utf8.RuneSelf || !multibyte {
			buf = append(buf, byte(c))
		} else {
			n := utf8.EncodeRune(runeTmp[:], c)
			buf = append(buf, runeTmp[:n]...)
		}
	}
	return string(buf), nil
}

func contains(s string, c byte) bool {
	return strings.IndexByte(s, c) != -1
}

repository: jinagamvasubabu/grule-rule-engine

repo_name: jinagamvasubabu/grule-rule-engine

gha_license_id: NOASSERTION


text:
@book{buttcher:2010:IR,
    abstract = {{Information retrieval is the foundation for modern search engines.  This text offers an introduction to the core topics underlying modern search technologies, including algorithms, data structures, indexing, retrieval, and evaluation.  The emphasis is on implementation and experimentation; each chapter includes exercises and suggestions for student projects.  Wumpus—a multiuser open-source information retrieval system developed by one of the authors and available online—provides model implementations and a basis for student work.  The modular structure of the book allows instructors to use it in a variety of graduate-level courses, including courses taught from a database systems perspective, traditional information retrieval courses with a focus on IR theory, and courses covering the basics of Web retrieval.After an introduction to the basics of information retrieval, the text covers three major topic areas—indexing, retrieval, and evaluation—in self-contained parts.  The final part of the book draws on and extends the general material in the earlier parts, treating such specific applications as parallel search engines, Web search, and XML retrieval.  End-of-chapter references point to further reading; exercises range from pencil and paper problems to substantial programming projects.  In addition to its classroom use, Information Retrieval will be a valuable reference for professionals in computer science, computer engineering, and software engineering.}},
    author = {B\"{u}ttcher, Stefan and Clarke, Charles L. A. and Cormack, Gordon V.},
    citeulike-article-id = {7811996},
    citeulike-linkout-0 = {http://ir.uwaterloo.ca/book},
    isbn = {978-0-262-02651-2},
    keywords = {ir, text\_book},
    posted-at = {2010-09-11 13:31:51},
    priority = {2},
    publisher = {MIT Press},
    title = {{Information Retrieval: Implementing and Evaluating Search Engines}},
    url = {http://ir.uwaterloo.ca/book},
    year = {2010}
}

@incollection{delbru:2009:lia2,
author = {Delbru, Renaud and Toupikov, Nickolai and Catasta, Michele and Fuller, Robert and Tummarello, Giovanni},
booktitle = {Lucene in Action, Second Edition},
chapter = {11},
publisher = {Manning Publications Co.},
title = {{SIREn: Efficient Search on Semi- Structured Documents}},
year = {2009}
}

@inproceedings{navarro:sigir1995:language-structure,
	address = {{New York, NY, USA}},
	booktitle = {{SIGIR '95: Proceedings of the 18th international conference on Research and Development in Information Retrieval}},
	Isbn = {{0-89791-714-6}},
	Location = {{Seattle, Washington, United States}},
	publisher = {{ACM}},
	author = {Gonzalo Navarro and Ricardo Baeza-Yates},
	title = {{A language for queries on structure and contents of textual databases}},
	pages = {93},
	year = {{1995}},
	doi = {{10.1145/215206.215336}},
}

@inproceedings{christophides:www2003:labeling-scheme,
	booktitle = {{WWW '03:Proceedings of the twelfth international conference on World Wide Web}},
	author = {Vassilis Christophides and Dimitris Plexousakis and Michel Scholl and Sotirios Tourtounis},
	title = {{On labeling schemes for the semantic web}},
	pages = {544},
	year = {{2003}},
	doi = {{10.1145/775152.775230}},
	tags = "Semantic Web, Information Retrieval"
}

@inproceedings{beyer:2002:ordered-xml,
 author = {Kevin Beyer and Stratis D. Viglas and Igor Tatarinov and Jayavel Shanmugasundaram and Eugene Shekita and Chun Zhang},
 title = {Storing and querying ordered XML using a relational database system},
 booktitle = {SIGMOD '02: Proceedings of the 2002 ACM SIGMOD international conference on Management of Data},
 year = {2002},
 isbn = {1-58113-497-5},
 pages = {204--215},
 location = {Madison, Wisconsin},
 doi = {10.1145/564691.564715},
 publisher = {ACM},
 address = {New York, NY, USA},
 }

@article{su-cheng:2009:survey-labeling,
	author = {Haw Su-Cheng and Lee Chien-Sing},
	title = {{Node Labeling Schemes in XML Query Optimization: A Survey and Trends}},
	journal = {{IETE Technical Review}},
	volume = {{26}},
	number = {{2}},
	pages = {88},
	year = {{2009}},
	doi = {{10.4103/0256-4602.49086}},
	tags = "Information Retrieval, Graph Labeling"
}

@inproceedings{harth:2005:index-structures,
author = {Harth, A. and Decker, S.},
booktitle = {Proceedings of the Third Latin American Web Congress (LA-WEB'2005)},
doi = {10.1109/LAWEB.2005.25},
isbn = {0-7695-2471-0},
pages = {71--80},
publisher = {IEEE},
title = {{Optimized Index Structures for Querying RDF from the Web}},
url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=1592360},
year = {2005}
}

@inproceedings{bast:2007:ester,
	address = {{New York, NY, USA}},
	booktitle = {{SIGIR '07: Proceedings of the 30th annual international ACM SIGIR conference}},
	isbn = {{978-1-59593-597-7}},
	publisher = {{ACM}},
	author = {Holger Bast and Alexandru Chitea and Fabian Suchanek and Ingmar Weber},
	title = {{ESTER: efficient search on text, entities, and relations}},
	pages = {671--678},
	year = {{2007}}
}

@article{graeffe:1993:query-evaluation,
	author = {Goetz Graefe},
	title = {{Query evaluation techniques for large databases}},
	journal = {{ACM Computing Surveys}},
	volume = {{25}},
	number = {{2}},
	pages = {73},
	year = {{1993}},
	doi = {{10.1145/152610.152611}}
}

@article{zobel:1996:guidelines,
	author = {Justin Zobel and Alistair Moffat and Kotagiri Ramamohanarao},
	title = {{Guidelines for presentation and comparison of indexing techniques}},
	journal = {{ACM SIGMOD Record}},
	volume = {{25}},
	number = {{3}},
	pages = {10},
	year = {{1996}},
	doi = {{10.1145/234889.234891}}
}

@article{btree-update:2006:graefe,
	author = {Goetz Graefe},
	title = {B-tree indexes for high update rates},
	journal = {ACM SIGMOD Record},
	volume = {35},
	number = {1},
	pages = {39},
	year = {2006},
	doi = {10.1145/1121995.1122002},
	tags = "Database"
}

@inproceedings{lim:2003:landmarks,
	booktitle = {{Proceedings of the 12th international conference on World Wide Web}},
	author = {Lipyeow Lim and Min Wang and Sriram Padmanabhan and Jeffrey Scott Vitter and Ramesh Agarwal},
	title = {{Dynamic maintenance of web indexes using landmarks}},
	pages = {102},
	year = {{2003}},
	doi = {{10.1145/775152.775167}}
}

@article{rdf3x:neumann:2008,
	publisher = {{VLDB Endowment}},
	author = {Thomas Neumann and Gerhard Weikum},
	title = {{RDF-3X - a RISC-style Engine for RDF}},
	journal = {{Proceedings of the VLDB Endowment}},
	volume = {{1}},
	number = {{1}},
	pages = {647--659},
	year = {{2008}},
	doi = {{10.1145/1453856.1453927}}
}

@article{2008:liang:semplore-dynamic,
	author = {Yan Liang and Haofen Wang and Qiaoling Liu and Thanh Tran and Thomas Penin and Yong Yu},
	title = {{Efficient Index Maintenance for Frequently Updated Semantic Data}},
	volume = {{5367}},
	pages = {182},
	year = {{2008}},
	doi = {{10.1007/978-3-540-89704-0_13}}
}

@article{hexastore:2008:weiss,
        author = {Cathrin Weiss and Panagiotis Karras and Abraham Bernstein},
        title = {Hexastore - Sextuple Indexing for Semantic Web Data Management},
        journal = {Proceedings of the VLDB Endowment},
        volume = {1},
        number = {1},
        pages = {1008--1019},
        year = {2008},
        doi = {10.1145/1453856.1453965}
}

repository: scampi/report-compression-skiplists

repo_name: scampi/report-compression-skiplists


text:
# BEGIN CMAKE PREPARATION

# setup cmake modules
SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake/platform/shared)

INCLUDE(idetectos)

IF(NOT CMAKE_BUILD_TYPE)
    #SET(CMAKE_BUILD_TYPE Debug)
    SET(CMAKE_BUILD_TYPE Release)
ENDIF()

SET(BUILD_SHARED_LIBS OFF)
SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS ON)
SET(GLOBAL_PROJECT_FOLDER "null")

INCLUDE(ioption)
INCLUDE(imacro)
INCLUDE(icompiler)
INCLUDE(ilinker)

SETUP_COMPILER_FLAGS()
SETUP_LINKER()
SETUP_TOOL_FLAGS()

# @todo. try to found good place for this code
IF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
    SET( GLOBAL_SEARCH_SUFFIX "x64" )
ELSE( CMAKE_SIZEOF_VOID_P EQUAL 8 )
    SET( GLOBAL_SEARCH_SUFFIX "x86" )
ENDIF( CMAKE_SIZEOF_VOID_P EQUAL 8 )

SET(LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})

# END CMAKE PREPARATION

repository: proydakov/cppzone

repo_name: proydakov/cppzone


text:
package main

import (
	"errors"
	"fmt"
	"os"
	"strings"
)

const rows, columns = 9, 9

// Grid is a Sudoku grid
type Grid [rows][columns]int8

// Errors that could occur.
var (
	ErrBounds = errors.New("out of bounds")
	ErrDigit  = errors.New("invalid digit")
)

// SudokuError is a slice of errors.
type SudokuError []error

// Error returns one or more errors separated by commas.
func (se SudokuError) Error() string {
	var s []string
	for _, err := range se {
		s = append(s, err.Error())
	}
	return strings.Join(s, ", ")
}

// Set a digit on a Sudoku grid
func (g *Grid) Set(row, column int, digit int8) error {
	var errs SudokuError
	if !inBounds(row, column) {
		errs = append(errs, ErrBounds)
	}
	if !validDigit(digit) {
		errs = append(errs, ErrDigit)
	}
	if len(errs) > 0 {
		return errs
	}

	g[row][column] = digit
	return nil
}

func inBounds(row, column int) bool {
	if row < 0 || row >= rows {
		return false
	}
	if column < 0 || column >= columns {
		return false
	}
	return true
}

func validDigit(digit int8) bool {
	return digit >= 1 && digit <= 9
}

func main() {
	var g Grid
	err := g.Set(10, 0, 15)
	if err != nil {
		if errs, ok := err.(SudokuError); ok {
			fmt.Printf("%d error(s) occurred:\n", len(errs))
			for _, e := range errs {
				fmt.Printf("- %v\n", e)
			}
		}
		os.Exit(1)
	}
}

repository: nuinattapon/get-programming-with-go

repo_name: nuinattapon/get-programming-with-go


text:
@Article{bogdan2008extending,
  title = {Extending the Modified Bayesian Information Criterion (mBIC) to dense markers and multiple interval mapping},
  author = {Ma{\l}gorzata Bogdan and Florian Frommlet and Przemys{\l}aw Biecek and Riyan Cheng and Jayanta K Ghosh and RW Doerge},
  journal = {Biometrics},
  volume = {64},
  number = {4},
  pages = {1162--1169},
  year = {2008},
  publisher = {Blackwell Publishing Inc Malden, USA},
}


text:
@article{Harris2016:Keep,
  title={Keep it local (and final): Remnant preferences in “let alone” ellipsis},
  author={Harris, Jesse A and Carlson, Katy},
  journal={The Quarterly Journal of Experimental Psychology},
  volume={69},
  number={7},
  pages={1278--1301},
  year={2016},
  publisher={Taylor \& Francis}
}


text:
%% This BibTeX bibliography file was created using BibDesk.
%% http://bibdesk.sourceforge.net/

%% Created for Vadim Martynov at 2019-09-06 02:37:06 -0700

%% Saved with string encoding Unicode (UTF-8)

@article{2013,
	Author = {Vadim Martynov},
	Date-Modified = {2019-09-06 09:36:59 +0000},
	Pages = {1-42},
	Title = {Subsidizing lemons for Efficient information aggregation},
	Year = {2018}}

url: https://raw.githubusercontent.com/MartynovVadim/academic-kickstart/30c9e70f0a40176efadfd5e6be5bc5a81d463a4e/content/publication/Subsidizing Lemons for Efficient information aggregation/cite.bib

repository: MartynovVadim/academic-kickstart

repo_name: MartynovVadim/academic-kickstart


text:
# base recipe: meta/recipes-graphics/xorg-lib/libxxf86dga_1.1.4.bb
# base branch: warrior
# base commit: 4ba923dbac2845aca5b4312a5f278ad886a7acc7

require ${COREBASE}/meta/recipes-graphics/xorg-lib/xorg-lib-common.inc

# clear SRC_URI
SRC_URI = ""
inherit debian-package
require recipes-debian/sources/libxxf86dga.inc
DEBIAN_PATCH_TYPE = "nopatch"
DEBIAN_UNPACK_DIR = "${WORKDIR}/${XORG_PN}-${PV}"

SUMMARY = "XFree86-DGA: XFree86 Direct Graphics Access extension library"

DESCRIPTION = "libXxf86dga provides the XFree86-DGA extension, which \
allows direct graphics access to a framebuffer-like region, and also \
allows relative mouse reporting, et al.  It is mainly used by games and \
emulators for games."

LIC_FILES_CHKSUM = "file://COPYING;md5=abb99ac125f84f424a4278153988e32f"

DEPENDS += "libxext"

PE = "1"

XORG_PN = "libXxf86dga"

repository: miraclelinux/meta-debian-extended

repo_name: miraclelinux/meta-debian-extended

branch_name: refs/heads/warrior


text:
@article{hayashi_aspergillus_2016,
 abstract = {Dust has been widely recognised as an important source of nutrients in the marine environment and as a vector for transporting pathogenic microorganisms. Disturbingly, in the wake of a dust storm event along the eastern Australian coast line in 2009, the Continuous Plankton Recorder collected masses of fungal spores and mycelia (~150,000 spores/m3) forming a ﬂoating raft that covered a coastal area equivalent to 25 times the surface of England. Cultured A. sydowii strains exhibited varying metabolite proﬁles, but all produced sydonic acid, a chemotaxonomic marker for A. sydowii. The Australian marine fungal strains share major metabolites and display comparable metabolic diversity to Australian terrestrial strains and to strains pathogenic to Caribbean coral. Secondary colonisation of the rafts by other fungi, including strains of Cladosporium, Penicillium and other Aspergillus species with distinct secondary metabolite proﬁles, was also encountered. Our bioassays revealed that the dust-derived marine fungal extracts and known A. sydowii metabolites such as sydowic acid, sydowinol and sydowinin A adversely affect photophysiological performance (Fv/Fm) of the coral reef dinoﬂagellate endosymbiont Symbiodinium. Different Symbiodinium clades exhibited varying sensitivities, mimicking sensitivity to coral bleaching phenomena. The detection of such large amounts of A. sydowii following this dust storm event has potential implications for the health of coral environments such as the Great Barrier Reef.},
 author = {Hayashi, Aiko and Crombie, Andrew and Lacey, Ernest and Richardson, Anthony and Vuong, Daniel and Piggott, Andrew and Hallegraeff, Gustaaf},
 doi = {10.3390/md14030059},
 file = {Hayashi et al. - 2016 - Aspergillus Sydowii Marine Fungal Bloom in Austral.pdf:/Users/ric325/Zotero/storage/BKQY32MF/Hayashi et al. - 2016 - Aspergillus Sydowii Marine Fungal Bloom in Austral.pdf:application/pdf},
 issn = {1660-3397},
 journal = {Marine Drugs},
 language = {en},
 month = {March},
 number = {3},
 pages = {59},
 title = {Aspergillus Sydowii Marine Fungal Bloom in Australian Coastal Waters, Its Metabolites and Potential Impact on Symbiodinium Dinoflagellates},
 url = {http://www.mdpi.com/1660-3397/14/3/59},
 urldate = {2019-10-24},
 volume = {14},
 year = {2016}
}


text:
package scraper

import (
	"time"
)

var (
	// DefaultRateLimiter is 45 queries in 60 second.
	// So roughly less than 1 query per second (1350ms between queries).
	DefaultRateLimiter = NewRateLimiter(45, 60*time.Second)
)

// RateLimiter holds rule for limiting queries in time.
// Strategy is as follows:
// While we are under the rate limiting rule, just download everything.
// When hitting the limit, wait and query at a slower pace.
// The goal here is to not wait for few queries, but still be gentle
// for the one with a lot of call to make.
type RateLimiter struct {
	// NbMaxQuery is the number of queries allowed.
	NbMaxQuery int
	// Window is the window used to count the number of queries.
	Window time.Duration
	// NbQuery is the number of query currently made.
	NbQuery int

	slowModeEnabled    bool
	slowMode           bool
	timeBetweenQueries time.Duration
	lastQuery          time.Time
}

// NewRateLimiter returns a new rate limiter.
func NewRateLimiter(nbMaxQuery int, window time.Duration) *RateLimiter {
	return &RateLimiter{
		NbMaxQuery: nbMaxQuery,
		Window:     window,
		NbQuery:    0,

		slowModeEnabled:    false,
		slowMode:           false,
		timeBetweenQueries: time.Duration(int64(window) / int64(nbMaxQuery)),
		lastQuery:          time.Time{},
	}
}

// nextQuery is the internal method for NextQuery with a choosable "now"
// mainly used to ease unit testing.
func (r *RateLimiter) nextQuery(now time.Time) (time.Duration, func(time.Time)) {
	queryDone := func(t time.Time) {
		r.NbQuery++
		r.lastQuery = t
	}

	if r.NbQuery < r.NbMaxQuery {
		return time.Duration(0), queryDone
	}

	elapsedTime := now.Sub(r.lastQuery)

	// Check if slow mode can be desactivated.
	if elapsedTime > r.Window {
		if elapsedTime > 2*r.Window {
			r.slowMode = false
		}
		r.NbQuery = 0
		return time.Duration(0), queryDone
	}

	// We hit the rate limit for the first time, so wait a bit
	// then switch into "slow mode".
	if !r.slowMode || !r.slowModeEnabled {
		r.slowMode = true
		return r.Window - elapsedTime, queryDone
	}

	return r.timeBetweenQueries - elapsedTime, queryDone
}

// EnableSlowMode enables slow mode.
// This mode allows to query slowly instead of querying by batch.
func (r *RateLimiter) EnableSlowMode() {
	r.slowModeEnabled = true
}

// NextQuery returns the time to wait before performing the next query.
// A closure function is returns which has to be called after the query has been
// called.
func (r *RateLimiter) NextQuery() (time.Duration, func()) {
	waitTime, queryDone := r.nextQuery(time.Now())
	return waitTime, func() { queryDone(time.Now()) }
}

repository: cptpingu/poe-stash

repo_name: cptpingu/poe-stash


text: @inproceedings{KapitsakiICWS2018,	Author = {Georgia Kapitsaki and Josef Ioannou and Jorge Cardoso and Carlos Pedrinaci},	Booktitle = {IEEE International Conference on Web Services (ICWS 2018)},	Date-Added = {2018-07-15 14:03:10 +0000},	Date-Modified = {2018-07-15 14:05:14 +0000},	Publisher = {Springer},	Title = {Linked USDL Privacy: Describing Privacy Policies for Service},	Year = {2018}}


text:
package acme

import (
	"testing"
)

func TestEncodeDns01KeyAuthorization(t *testing.T) {
	tests := []struct {
		KeyAuth string
		Encoded string
	}{
		{
			"YLhavngUj1w8B79rUzxB5imUvO8DPyLDHgce89NuMfw.4fqGG7OQog-EV3ovi0b_amhdzVNWxxswDUN9ypYhWpE",
			"vKcNRAl8IQoDxFFQbEmXHgZ8O1rYk3JTFooIfYJDEEU",
		},
	}

	for _, currentTest := range tests {
		e := EncodeDNS01KeyAuthorization(currentTest.KeyAuth)
		if e != currentTest.Encoded {
			t.Fatalf("expected: %s, got: %s", currentTest.Encoded, e)
		}
	}
}

func TestClient_UpdateChallenge(t *testing.T) {
	account, order := makeOrder(t)
	auth, err := testClient.FetchAuthorization(account, order.Authorizations[0])
	if err != nil {
		t.Fatalf("unexpected error fetching authorization: %v", err)
	}

	chal := auth.ChallengeMap[ChallengeTypeDNS01]

	preChallenge(auth, chal)
	defer postChallenge(auth, chal)

	updatedChal, err := testClient.UpdateChallenge(account, chal)
	if err != nil {
		t.Fatalf("expected no error, got: %v", err)
	}

	if updatedChal.Status != "valid" {
		t.Fatalf("expected valid challenge, got: %s", chal.Status)
	}
}

func TestClient_FetchChallenge(t *testing.T) {
	account, order := makeOrder(t)
	auth, err := testClient.FetchAuthorization(account, order.Authorizations[0])
	if err != nil {
		t.Fatalf("unexpected error fetching authorization: %v", err)
	}

	chal := auth.Challenges[0]

	fetchedChal, err := testClient.FetchChallenge(account, chal.URL)
	if err != nil {
		t.Fatalf("expected no error, got: %v", err)
	}

	if chal.Token != fetchedChal.Token {
		t.Fatalf("tokens different")
	}
}

func Test_checkUpdatedChallengeStatus(t *testing.T) {
	tests := []struct {
		Status   string
		Finished bool
		HasError bool
	}{
		{
			Status: "pending",
		},
		{
			Status: "processing",
		},
		{
			Status:   "valid",
			Finished: true,
		},
		{
			Status:   "invalid",
			Finished: true,
			HasError: true,
		},
		{
			Status:   "blah",
			Finished: true,
			HasError: true,
		},
	}
	for _, ct := range tests {
		finished, err := checkUpdatedChallengeStatus(Challenge{
			Status: ct.Status,
		})
		if ct.Finished != finished {
			t.Fatalf("Finished mismatch on status %s, expected: %t got: %t", ct.Status, ct.Finished, finished)
		}
		if ct.HasError && err == nil {
			t.Fatalf("status %s expected error, got none", ct.Status)
		}
		if !ct.HasError && err != nil {
			t.Fatalf("status %s expected no error, got: %v", ct.Status, err)
		}
	}
}

repository: eggsampler/acme

repo_name: eggsampler/acme


text:
DESCRIPTION = "The MusicBrainz client is a library which can be built into other programs.  The library allows you to access the data held on the MusicBrainz server."
HOMEPAGE = "http://musicbrainz.org"
MAINTAINER = "Koen Kooi <koen@dominion.kabel.utwente.nl>"
LICENSE = "LGPL"
DEPENDS = "expat"

SRC_URI = "http://ftp.musicbrainz.org/pub/musicbrainz/libmusicbrainz-2.1.2.tar.gz"

inherit autotools pkgconfig

do_stage() {
autotools_stage_all
}


text:
// Copyright (C) 2019-2023, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.

// For ease of implementation, our database's interface matches Ethereum's
// database implementation. This was to allow us to use Geth code as is for the
// EVM chain.

package database

import "golang.org/x/exp/slices"

// Batch is a write-only database that commits changes to its host database
// when Write is called. A batch cannot be used concurrently.
type Batch interface {
	KeyValueWriterDeleter

	// Size retrieves the amount of data queued up for writing, this includes
	// the keys, values, and deleted keys.
	Size() int

	// Write flushes any accumulated data to disk.
	Write() error

	// Reset resets the batch for reuse.
	Reset()

	// Replay replays the batch contents in the same order they were written
	// to the batch.
	Replay(w KeyValueWriterDeleter) error

	// Inner returns a Batch writing to the inner database, if one exists. If
	// this batch is already writing to the base DB, then itself should be
	// returned.
	Inner() Batch
}

// Batcher wraps the NewBatch method of a backing data store.
type Batcher interface {
	// NewBatch creates a write-only database that buffers changes to its host db
	// until a final write is called.
	NewBatch() Batch
}

type BatchOp struct {
	Key    []byte
	Value  []byte
	Delete bool
}

type BatchOps struct {
	Ops  []BatchOp
	size int
}

func (b *BatchOps) Put(key, value []byte) error {
	b.Ops = append(b.Ops, BatchOp{
		Key:   slices.Clone(key),
		Value: slices.Clone(value),
	})
	b.size += len(key) + len(value)
	return nil
}

func (b *BatchOps) Delete(key []byte) error {
	b.Ops = append(b.Ops, BatchOp{
		Key:    slices.Clone(key),
		Delete: true,
	})
	b.size += len(key)
	return nil
}

func (b *BatchOps) Size() int {
	return b.size
}

func (b *BatchOps) Reset() {
	b.Ops = b.Ops[:0]
	b.size = 0
}

func (b *BatchOps) Replay(w KeyValueWriterDeleter) error {
	for _, op := range b.Ops {
		if op.Delete {
			if err := w.Delete(op.Key); err != nil {
				return err
			}
		} else if err := w.Put(op.Key, op.Value); err != nil {
			return err
		}
	}
	return nil
}

repository: ava-labs/avalanchego

repo_name: ava-labs/avalanchego


text:
@article{art_spic18,
 author = {C. Meillier and R. Ammanouil and A. Ferrari and P.
Bianchi},
 journal = {Signal Processing: Image Communication},
 month = {September},
 pages = {149--160},
 publisher = {Elsevier BV},
 title = {Distribution strategies for very large 3D image
deconvolution algorithms},
 volume = {67},
 year = {2018}
}

repository: andferrari/academic-kickstart

repo_name: andferrari/academic-kickstart


text:
KBRANCH ?= "dev-4.7"
LINUX_VERSION ?= "4.7.10"

SRCREV="15c30d4deb0a01f398230395dc0d9af4be92d856"

require linux-obmc.inc

repository: kusanager/openbmc

repo_name: kusanager/openbmc


text:
@TechReport{BornEtalMMN2022,
  author = {Benjamin Born and Zeno Enders and Manuel Menkhoff and Gernot J. M\"uller and Knut Niemann},
  title  = {Firm Expectations and News: Micro v Macro},
  year   = {2023},
  type      = {CEPR Discussion Papers},
  number    = {17768}
}

repository: BenjaminBorn/academic-kickstart

repo_name: BenjaminBorn/academic-kickstart


text:
package main

import (
	"fmt"

	"github.com/anaskhan96/soup"
	utils "github.com/aosousa/golang-utils"
)

const (
	baseLeaguepediaURL = "https://lol.gamepedia.com"
	version            = "1.0.0"
)

// Prints the list of accepted commands
func printHelp() {
	fmt.Printf("LoL Pro Player Stats (version %s)\n", version)
	fmt.Println("Available commands:")
	fmt.Println("* -h | --help\t Prints the list of available commands")
	fmt.Println("* -v | --version Prints the version of the application")
	fmt.Println("* PLAYER CODE SPLIT YEAR Prints the statistics of a player in a given split of a given year (e.g. lol-pro-player-stats.exe Perkz LEC Summer 2019)")
}

// Prints the current version of the application
func printVersion() {
	fmt.Printf("LoL Pro Player Stats version %s\n", version)
}

/* Handles a request to lookup information related to a player
 * Receives:
 * args ([]string) - Arguments passed in the terminal by the user
 */
func handlePlayerOptions(args []string) {
	var (
		queryURL, player, leagueCode, split, year string
	)

	player, leagueCode, split, year = args[1], args[2], args[3], args[4]
	queryURL = baseLeaguepediaURL + "/Special:RunQuery/MatchHistoryPlayer?MHP%5Bpreload%5D=Player&MHP%5Btournament%5D=" + leagueCode + "%20" + year + "%20" + split + "&MHP%5Bspl%5D=yes&MHP%5Blink%5D=" + player + "&pfRunQueryFormName=MatchHistoryPlayer"
	resp, err := soup.Get(queryURL)
	if err != nil {
		utils.HandleError(err)
	}

	printPlayerTable(player, leagueCode, split, year, resp)
}

/* Print a player's champion stats in a given split of a given year.
 * Receives:
 * player (string) - Player's in game handle
 * leagueCode (string) - Code of the league (LCS, LEC, etc.)
 * split (string) - Split of the league season (Spring, Summer, Winter)
 * year (string) - Year of the season
 * document (string) - Leaguepedia page HTML document
 */
func printPlayerTable(player, leagueCode, split, year, document string) {
	fmt.Printf(" %s %s %s %s Stats\n\n", player, leagueCode, split, year)
	fmt.Println(" Champion \t|  G  |  W  |  L  | WR    | KDA")

	doc := soup.HTMLParse(document)
	championTable := doc.Find("table", "class", "spstats")
	championTableBody := championTable.Find("tbody")
	championTableBodyRows := championTableBody.Children()

	for _, row := range championTableBodyRows {
		// only want TD elements inside tbody
		if row.Children()[0].NodeValue == "td" {
			championName := row.Children()[0].Children()[1].NodeValue
			championNameDistance := utils.CalculateStringDistance(15, championName)

			games := row.Children()[1].Children()[0].Text()
			gamesDistance := utils.CalculateStringDistance(1, games)

			wins := row.Children()[2].Text()
			losses := row.Children()[3].Text()

			winratio := row.Children()[4].Text()
			winratioDistance := utils.CalculateStringDistance(4, winratio)
			kda := row.Children()[8].Text()

			fmt.Printf("%s %s|  %s %s|  %s  |  %s  | %s %s| %s\n", championName, championNameDistance, games, gamesDistance, wins, losses, winratio, winratioDistance, kda)
		}
	}
}

repository: aosousa/lol-pro-player-stats

repo_name: aosousa/lol-pro-player-stats


text:
%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author          = "Nelson H. F. Beebe",
%%%     version         = "1.37",
%%%     date            = "15 December 2012",
%%%     time            = "08:47:49 MST",
%%%     filename        = "ieeetranspardistsys.bib",
%%%     address         = "University of Utah
%%%                        Department of Mathematics, 110 LCB
%%%                        155 S 1400 E RM 233
%%%                        Salt Lake City, UT 84112-0090
%%%                        USA",
%%%     telephone       = "+1 801 581 5254",
%%%     FAX             = "+1 801 581 4148",
%%%     URL             = "http://www.math.utah.edu/~beebe",
%%%     checksum        = "33044 74103 292384 3203045",
%%%     email           = "beebe at math.utah.edu, beebe at acm.org,
%%%                        beebe at computer.org (Internet)",
%%%     codetable       = "ISO/ASCII",
%%%     keywords        = "BibTeX, bibliography, IEEE Transactions on
%%%                        Parallel and Distributed Systems",
%%%     license         = "public domain",
%%%     supported       = "yes",
%%%     docstring       = "This is an almost complete bibliography of
%%%                        the journal IEEE Transactions on Parallel
%%%                        and Distributed Systems (CODEN ITDSEO, ISSN
%%%                        1045-9219 (print), 1558-2183 (electronic)),
%%%                        which began with volume 1 in January 1990. It
%%%                        was published quarterly in 1990 and 1991,
%%%                        then went to five issues in 1992, and from
%%%                        1993, has appeared monthly.
%%%
%%%                        There are World-Wide Web sites for the
%%%                        journal at
%%%
%%%                            http://www2.computer.org/portal/web/csdl/transactions/tpds
%%%                            http://www.computer.org/pubs/tpds/tpds.htm
%%%                            http://www.computer.org/tpds/archives.htm
%%%                            http://www.computer.org/portal/web/csdl/transactions/tpds#1
%%%
%%%                        That site offers full-text versions in Adobe
%%%                        Acrobat Portable Document Format (PDF) of
%%%                        journal issues from November 1996 to date,
%%%                        and up to two months before the printed
%%%                        issues appear.  For the first part of 1997,
%%%                        this material is accessible to anyone;
%%%                        after that, IEEE membership and later, a
%%%                        journal subscription, will be required.
%%%
%%%                        At version 1.37, the year coverage looked
%%%                        like this:
%%%
%%%                             1990 (  43)    1998 ( 105)    2006 ( 125)
%%%                             1991 (  43)    1999 ( 102)    2007 ( 140)
%%%                             1992 (  64)    2000 (  88)    2008 ( 132)
%%%                             1993 ( 116)    2001 ( 104)    2009 ( 143)
%%%                             1994 ( 124)    2002 ( 100)    2010 ( 142)
%%%                             1995 ( 126)    2003 ( 106)    2011 ( 195)
%%%                             1996 ( 115)    2004 (  95)    2012 ( 233)
%%%                             1997 ( 116)    2005 ( 103)
%%%
%%%                             Article:       2660
%%%
%%%                             Total entries: 2660
%%%
%%%                        Data for this bibliography has been collected
%%%                        from the Compendex database (1990--1996),
%%%                        from the IEEE INSPEC database (1990--1996),
%%%                        from the MathSciNet database, from the
%%%                        bibliographies in the TeX User Group
%%%                        collection, from bibliographies in the
%%%                        author's personal files, and from the
%%%                        computer science bibliography collection on
%%%                        ftp.ira.uka.de in /pub/bibliography to which
%%%                        many people of have contributed.  The
%%%                        snapshot of this collection was taken on
%%%                        5-May-1994, and it consists of 441 BibTeX
%%%                        files, 2,672,675 lines, 205,289 entries, and
%%%                        6,375 <at>String{} abbreviations, occupying
%%%                        94.8MB of disk space.  There is NO coverage
%%%                        of this journal in the OCLC Contents1st
%%%                        database.
%%%
%%%                        Numerous errors in the sources noted above
%%%                        have been corrected.   Spelling has been
%%%                        verified with the UNIX spell and GNU ispell
%%%                        programs using the exception dictionary
%%%                        stored in the companion file with extension
%%%                        .sok.
%%%
%%%                        BibTeX citation tags are uniformly chosen
%%%                        as name:year:abbrev, where name is the
%%%                        family name of the first author or editor,
%%%                        year is a 4-digit number, and abbrev is a
%%%                        3-letter condensation of important title
%%%                        words. Citation tags were automatically
%%%                        generated by software developed for the
%%%                        BibNet Project.
%%%
%%%                        In this bibliography, entries are sorted in
%%%                        publication order, using ``bibsort -byvolume''.
%%%
%%%                        The checksum field above contains a CRC-16
%%%                        checksum as the first value, followed by the
%%%                        equivalent of the standard UNIX wc (word
%%%                        count) utility output of lines, words, and
%%%                        characters.  This is produced by Robert
%%%                        Solovay's checksum utility.",
%%%  }
%%% ====================================================================

@Preamble{
    "\ifx \lozenge \undefined \def \lozenge {[\em lozenge\/]} \fi"
}

%%% ====================================================================
%%% Acknowledgement abbreviations:

@String{ack-nhfb = "Nelson H. F. Beebe,
                    University of Utah,
                    Department of Mathematics, 110 LCB,
                    155 S 1400 E RM 233,
                    Salt Lake City, UT 84112-0090, USA,
                    Tel: +1 801 581 5254,
                    FAX: +1 801 581 4148,
                    e-mail: \path|beebe@math.utah.edu|,
                            \path|beebe@acm.org|,
                            \path|beebe@computer.org| (Internet),
                    URL: \path|http://www.math.utah.edu/~beebe/|"}

%%% ====================================================================
%%% Journal abbreviations:

@String{j-IEEE-TRANS-PAR-DIST-SYS = "IEEE Transactions on Parallel and
                                    Distributed Systems"}

%%% ====================================================================
%%% Bibliography entries:
@Article{Bulut:2012:EFR,
  author =       "Eyuphan Bulut and Boleslaw K. Szymanski",
  title =        "Exploiting Friendship Relations for Efficient Routing
                 in Mobile Social Networks",
  journal =      j-IEEE-TRANS-PAR-DIST-SYS,
  volume =       "23",
  number =       "12",
  pages =        "2254--2265",
  month =        dec,
  year =         "2012",
  CODEN =        "ITDSEO",
  DOI =          "http://doi.ieeecomputersociety.org/10.1109/TPDS.2012.83",
  ISSN =         "1045-9219 (print), 1558-2183 (electronic)",
  ISSN-L =       "1045-9219",
  bibdate =      "Thu Nov 15 06:27:40 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/ieeetranspardistsys.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Parallel and Distributed Systems",
}

filename: ieeetranspardistsys - копия.bib


text:
package bilierrorcode

func getBBQCodeDetail(code ErrorCode) ErrorCodeDetail {
	result := ErrorCodeDetail{
		Code:        code,
		Message:     "",
		Description: "",
	}

	switch code {
	case 3001016:
		result.Message = "CheckInviteCodeErr"
		result.Description = "检查邀请码失败(特殊处理请勿修改) todo"
		break

	// Common [5000000,5001000)
	case 5000000:
		result.Message = "Common"
		result.Description = ""
		break
	case 5000001:
		result.Message = "TypeDismatch"
		result.Description = "类型不匹配"
		break
	case 5000002:
		result.Message = "ExternalErr"
		result.Description = "外部错误"
		break
	case 5000003:
		result.Message = "ReqParamErr"
		result.Description = "参数错误"
		break
	case 5000004:
		result.Message = "BBQSystemErr"
		result.Description = "用于一些异常请求"
		break
	case 5000005:
		result.Message = "BBQNoBindPhone"
		result.Description = "未绑定手机号"
		break
	case 5000006:
		result.Message = "BBQUserBanned"
		result.Description = "已被封禁，无法进行相关操作，如有疑问可在“设置-吐槽”中进行反馈"
		break
	case 5000007:
		result.Message = "ArchiveDatabusNilErr"
		result.Description = "预发环境不配置稿件databus"
		break

	// Search [5001000,5002000)
	case 5001000:
		result.Message = "SearchCreateIndexErr"
		result.Description = "创建索引失败"
		break
	case 5001001:
		result.Message = "SearchVideoDataErr"
		result.Description = "获取视频信息失败"
		break

	// web [5002000,5003000)
	case 5002001:
		result.Message = "CommentClosed"
		result.Description = "评论已关闭"
		break
	case 5002003:
		result.Message = "VideoUnExists"
		result.Description = "视频不存在"
		break
	case 5002004:
		result.Message = "VideoUnReachable"
		result.Description = "视频不存在，由于状态原因不可访问"
		break
	case 5002005:
		result.Message = "VideoInAudit"
		result.Description = "视频审核中"
		break
	case 5002014:
		result.Message = "InviteCodeInvalid"
		result.Description = "无效邀请码"
		break
	case 5002015:
		result.Message = "InviteCodeUsed"
		result.Description = "邀请码已使用"
		break
	case 5002021:
		result.Message = "CommentForbidden"
		result.Description = "禁止评论"
		break
	case 5002023:
		result.Message = "CommentTooShort"
		result.Description = "评论过短"
		break
	case 5002024:
		result.Message = "CommentTooLong"
		result.Description = "评论过长"
		break
	case 5002025:
		result.Message = "SvNotReachable"
		result.Description = ""
		break
	case 5002026:
		result.Message = "NoticeTypeErr"
		result.Description = "通知类型错误"
		break
	case 5002027:
		result.Message = "CommentForbidLike"
		result.Description = "禁止赞或踩"
		break
	case 5002028:
		result.Message = "CommentLengthIllegal"
		result.Description = "评论长度不合法"
		break

	// video-service [5003000,5004000)
	case 5003000:
		result.Message = "UnKnownBPS"
		result.Description = "未知码率"
		break
	case 5003001:
		result.Message = "SyncBVCFail"
		result.Description = "同步bvc转码失败"
		break
	case 5003002:
		result.Message = "VideoDelFail"
		result.Description = "视频删除失败，不能删除别人的视频"
		break

	// UserLike [5005000, 5005100]
	case 5005000:
		result.Message = "UserLike"
		result.Description = "UserLike [5005000, 5005100]"
		break
	case 5005001:
		result.Message = "AddUserLikeErr"
		result.Description = "点赞失败"
		break
	case 5005002:
		result.Message = "CancelUserLikeErr"
		result.Description = "取消点赞失败"
		break

	// UserInfo [5005100, 5005200]
	case 5005100:
		result.Message = "UserInfo"
		result.Description = "UserInfo"
		break
	case 5005101:
		result.Message = "BatchUserTooLong"
		result.Description = "用户批量请求太多"
		break
	case 5005102:
		result.Message = "UPMIDNotExists"
		result.Description = "up主不存在"
		break
	case 5005103:
		result.Message = "GetUserBaseErr"
		result.Description = "获取用户信息失败"
		break
	case 5005104:
		result.Message = "EditUserBaseErr"
		result.Description = "更新用户基础信息失败"
		break
	case 5005105:
		result.Message = "UserUnameSpecial"
		result.Description = "昵称包含特殊字符"
		break
	case 5005106:
		result.Message = "UserUnameLength"
		result.Description = "昵称长度不符合"
		break
	case 5005107:
		result.Message = "UserUnameExisted"
		result.Description = "昵称已被占用"
		break
	case 5005108:
		result.Message = "UserUnameFilterErr"
		result.Description = "昵称包含敏感词"
		break
	case 5005109:
		result.Message = "UserUnamePrefixErr"
		result.Description = "该昵称无法注册"
		break

	// UserRelation [5005200, 5005300]
	case 5005200:
		result.Message = "UserRelation"
		result.Description = ""
		break
	case 5005201:
		result.Message = "AddUserFollowErr"
		result.Description = "关注失败，请稍后重试"
		break
	case 5005202:
		result.Message = "CancelUserFollowErr"
		result.Description = "取消关注失败，请稍后重试"
		break
	case 5005203:
		result.Message = "UserFollowLimitErr"
		result.Description = "关注失败，关注已达上限"
		break
	case 5005204:
		result.Message = "FollowMyselfErr"
		result.Description = "不能关注自己"
		break
	case 5005205:
		result.Message = "UserAlreadyBlackFollowErr"
		result.Description = "关注失败，请将用户移出黑名单后重试"
		break
	case 5005206:
		result.Message = "UserBlackLimitErr"
		result.Description = "拉黑失败，黑名单已达上限"
		break
	case 5005207:
		result.Message = "UserBlackErr"
		result.Description = "黑名单请求系统错误"
		break
	case 5005208:
		result.Message = "UserBlackSelfErr"
		result.Description = "拉黑失败，不能拉黑自己"
		break

	// Danmu [5005300, 5005400]
	case 5005300:
		result.Message = "Danmu"
		result.Description = ""
		break
	case 5005301:
		result.Message = "FilterErr"
		result.Description = "弹幕包含敏感词"
		break
	case 5005302:
		result.Message = "DanmuGetErr"
		result.Description = "弹幕获取失败"
		break
	case 5005303:
		result.Message = "DanmuPostErr"
		result.Description = "弹幕发送失败"
		break
	case 5005304:
		result.Message = "DanmuLimitErr"
		result.Description = "该视频暂时无法发送弹幕"
		break

		// Comment [5005400, 5005500]
	case 5005400:
		result.Message = "Comment"
		result.Description = ""
		break
	case 5005401:
		result.Message = "CommentFilterErr"
		result.Description = "评论包含敏感词"
		break
	case 5005402:
		result.Message = "CommentMissErr"
		result.Description = "评论不见了"
		break
	case 5005403:
		result.Message = "CommentLengthErr"
		result.Description = "评论需要2-96字"
		break
	case 5005404:
		result.Message = "CommentOptLimitErr"
		result.Description = "操作太快了，休息一下"
		break
	case 5005405:
		result.Message = "CommentLimithErr"
		result.Description = "该视频暂时无法发送评论"
		break

		// report [5005500, 5005599]
	case 5005501:
		result.Message = "ReportDanmuError"
		result.Description = "弹幕举报失败"
		break

		//Upload [5005600, 5005700]
	case 5005600:
		result.Message = "Upload"
		result.Description = ""
		break
	case 5005601:
		result.Message = "UploadFailed"
		result.Description = "上传失败"
		break

		// Topic [5005700, 5005800]
	case 5005700:
		result.Message = "Topic"
		result.Description = ""
		break
	case 5005701:
		result.Message = "TopicReqParamErr"
		result.Description = "参数错误"
		break
	case 5005702:
		result.Message = "TopicNumTooManyErr"
		result.Description = "一次性插入db的话题数量太大"
		break
	case 5005703:
		result.Message = "TopicNameLenErr"
		result.Description = "话题长度太长"
		break
	case 5005704:
		result.Message = "TopicIDErr"
		result.Description = "话题ID错误"
		break
	case 5005705:
		result.Message = "TopicIDNotFound"
		result.Description = "话题ID没找到"
		break
	case 5005706:
		result.Message = "TopicStateErr"
		result.Description = "话题为下架状态"
		break
	case 5005707:
		result.Message = "TopicTooManyInOneVideo"
		result.Description = "一个视频的话题数量太多了"
		break
	case 5005708:
		result.Message = "TopicDescLenErr"
		result.Description = "话题描述长度太长"
		break
	case 5005709:
		result.Message = "TopicInsertErr"
		result.Description = "话题插入失败"
		break
	case 5005721:
		result.Message = "TopicVideoStateErr"
		result.Description = "话题视频状态错误"
		break
	}
	return result
}


text:
// Copyright © 2022 Ory Corp
// SPDX-License-Identifier: Apache-2.0

package config

import (
	"strings"

	"github.com/ory/x/stringsx"
)

// AccessTokenStrategyType is the type of access token strategy.
type AccessTokenStrategyType string

const (
	// AccessTokenJWTStrategy is the JWT access token strategy.
	AccessTokenJWTStrategy AccessTokenStrategyType = "jwt"
	// AccessTokenDefaultStrategy is the default access token strategy using HMAC-SHA pass-by-reference tokens.
	AccessTokenDefaultStrategy AccessTokenStrategyType = "opaque"
)

// ToAccessTokenStrategyType converts a string to an AccessTokenStrategyType
func ToAccessTokenStrategyType(strategy string) (AccessTokenStrategyType, error) {
	switch f := stringsx.SwitchExact(strings.ToLower(strategy)); {
	case f.AddCase("jwt"):
		return AccessTokenJWTStrategy, nil
	case f.AddCase("opaque"):
		return AccessTokenDefaultStrategy, nil
	default:
		return "", f.ToUnknownCaseErr()
	}
}

repository: ory/hydra

repo_name: ory/hydra


text:
# Copyright (C) 2014-2019 Linaro
# Released under the MIT license (see COPYING.MIT for the terms)

DESCRIPTION = "Linaro Qualcomm Landing team 5.7 Kernel"
LIC_FILES_CHKSUM = "file://COPYING;md5=6bc538ed5bd9a7fc9398086aedcd7e46"

inherit python3native

require recipes-kernel/linux/linux-linaro-qcom.inc
require recipes-kernel/linux/linux-qcom-bootimg.inc

SRC_URI_append_qrb5165-rb5 = " \
    file://qrb5165-rb5.dts;subdir=git/arch/arm64/boot/dts/qcom \
    file://qrb5165-rb5-enable.patch \
    file://0001-arm64-dts-qcom-sm8250-change-spmi-node-label.patch \
    file://0001-arm64-dts-qcom-sm8250-add-I2C-and-SPI-nodes.patch \
    file://0001-arm64-dts-qcom-sm8250-Add-USB-and-PHY-device-nodes.patch \
    file://0001-arm64-dts-qcom-sm8250-Rename-UART2-node-to-UART12.patch \
    file://0001-arm64-dts-qcom-sm8250-Add-support-for-SDC2.patch \
"

LOCALVERSION ?= "-linaro-lt-qcom"
SRCBRANCH ?= "release/qcomlt-5.7"
SRCREV ?= "4af49ea41ecf17e5e6243f3ac81dfc2f84d8a3a1"

COMPATIBLE_MACHINE = "(qcom)"

# Wifi firmware has a recognizable arch :(
ERROR_QA_remove = "arch"

repository: olivierschonken/meta-qcom

repo_name: olivierschonken/meta-qcom


text:
option (USE_COMBBLAS "Build with CombBLAS Matrix support" OFF)
if (USE_COMBBLAS)
  set (CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/CMakeModules")
  find_package(CombBLAS REQUIRED)
  if (CombBLAS_FOUND)
    include_directories (${CombBLAS_INCLUDE_DIR})
    link_directories (${CombBLAS_LIBRARY_DIR})

    # use Boost fallback if we don't have c++11 capabilities
    if(NOT CXX11_COMPILER_FLAGS)
      add_definitions(-DCOMBBLAS_BOOST)
    endif(NOT CXX11_COMPILER_FLAGS)

    add_definitions(-D__STDC_LIMIT_MACROS)
    set (SKYLARK_HAVE_COMBBLAS
         1
         CACHE
         STRING
         "Enables use of CombBLAS Libraries"
         FORCE)
  endif (CombBLAS_FOUND)
endif (USE_COMBBLAS)

repository: NaHenn/libskylark

repo_name: NaHenn/libskylark


text:
@inproceedings{gungor2018improving,
 author = {Gungor, Onur and Uskudarli, Suzan and Gungor, Tunga},
 booktitle = {Proceedings of the 27th International Conference on Computational Linguistics (COLING 2018)},
 pages = {2082--2092},
 title = {Improving Named Entity Recognition by Jointly Learning to Disambiguate Morphological Tags},
 year = {2018}
}

gha_language: Jupyter Notebook


text:
@article{DBLP:journals/tosem/BaresiP05,
  author    = {Luciano Baresi and
               Mauro Pezz{\`{e}}},
  title     = {Formal interpreters for diagram notations},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {1},
  pages     = {42--84},
  year      = {2005}
}

@article{DBLP:journals/tosem/BerstelCRP05,
  author    = {Jean Berstel and
               Stefano Crespi{-}Reghizzi and
               Gilles Roussel and
               Pierluigi San Pietro},
  title     = {A scalable formal method for design and automatic checking of user
               interfaces},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {2},
  pages     = {124--167},
  year      = {2005}
}

@article{DBLP:journals/tosem/DashofyHT05,
  author    = {Eric M. Dashofy and
               Andr{\'{e}} van der Hoek and
               Richard N. Taylor},
  title     = {A comprehensive approach for the development of modular software architecture
               description languages},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {2},
  pages     = {199--245},
  year      = {2005}
}

@article{DBLP:journals/tosem/ErwigF05,
  author    = {Martin Erwig and
               Zhe Fu},
  title     = {Software reuse for scientific computing through program generation},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {2},
  pages     = {168--198},
  year      = {2005}
}

@article{DBLP:journals/tosem/EstublierLHCCTW05,
  author    = {Jacky Estublier and
               David B. Leblang and
               Andr{\'{e}} van der Hoek and
               Reidar Conradi and
               Geoffrey Clemm and
               Walter F. Tichy and
               Darcy Wiborg Weber},
  title     = {Impact of software engineering research on the practice of software
               configuration management},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {4},
  pages     = {383--430},
  year      = {2005}
}

@article{DBLP:journals/tosem/FriasPBAM05,
  author    = {Marcelo F. Frias and
               Carlos L{\'{o}}pez Pombo and
               Gabriel A. Baum and
               Nazareno Aguirre and
               T. S. E. Maibaum},
  title     = {Reasoning about static and dynamic properties in alloy: {A} purely
               relational approach},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {4},
  pages     = {478--526},
  year      = {2005}
}

@article{DBLP:journals/tosem/GervasiZ05,
  author    = {Vincenzo Gervasi and
               Didar Zowghi},
  title     = {Reasoning about inconsistencies in natural language requirements},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {3},
  pages     = {277--330},
  year      = {2005}
}

@article{DBLP:journals/tosem/Ghezzi05,
  author    = {Carlo Ghezzi},
  title     = {Editorial},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {2},
  pages     = {119--123},
  year      = {2005}
}

@article{DBLP:journals/tosem/KlintLV05,
  author    = {Paul Klint and
               Ralf L{\"{a}}mmel and
               Chris Verhoef},
  title     = {Toward an engineering discipline for grammarware},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {3},
  pages     = {331--380},
  year      = {2005}
}

@article{DBLP:journals/tosem/LauY05,
  author    = {Man Fai Lau and
               Yuen{-}Tak Yu},
  title     = {An extended fault class hierarchy for specification-based testing},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {3},
  pages     = {247--276},
  year      = {2005}
}

@article{DBLP:journals/tosem/MilanovaRR05,
  author    = {Ana Milanova and
               Atanas Rountev and
               Barbara G. Ryder},
  title     = {Parameterized object sensitivity for points-to analysis for Java},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {1},
  pages     = {1--41},
  year      = {2005}
}

@article{DBLP:journals/tosem/OsterweilGKW05,
  author    = {Leon J. Osterweil and
               Carlo Ghezzi and
               Jeff Kramer and
               Alexander L. Wolf},
  title     = {Editorial},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {4},
  pages     = {381--382},
  year      = {2005}
}

@article{DBLP:journals/tosem/RyderSB05,
  author    = {Barbara G. Ryder and
               Mary Lou Soffa and
               Margaret M. Burnett},
  title     = {The impact of software engineering research on modern programming
               languages},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {4},
  pages     = {431--477},
  year      = {2005}
}

@article{DBLP:journals/tosem/SommervilleR05,
  author    = {Ian Sommerville and
               Jane Ransom},
  title     = {An empirical study of industrial requirements engineering process
               assessment and improvement},
  journal   = {{ACM} Trans. Softw. Eng. Methodol.},
  volume    = {14},
  number    = {1},
  pages     = {85--117},
  year      = {2005}
}

path: /raw data/TOSEM05.bib


text:
package portaudio

import (
	"fmt"

	"github.com/asticode/go-astikit"
	"github.com/gordonklaus/portaudio"
)

type PortAudio struct {
	l astikit.SeverityLogger
}

func New(l astikit.StdLogger) *PortAudio {
	return &PortAudio{l: astikit.AdaptStdLogger(l)}
}

func (p *PortAudio) Initialize() (err error) {
	// Log
	p.l.Debug("portaudio: initializing portaudio")

	// Initialize
	if err = portaudio.Initialize(); err != nil {
		err = fmt.Errorf("portaudio: initializing portaudio failed: %w", err)
		return
	}
	return
}

func (p *PortAudio) Close() (err error) {
	// Log
	p.l.Debug("astiportaudio: terminating portaudio")

	// Terminate
	if err = portaudio.Terminate(); err != nil {
		err = fmt.Errorf("astiportaudio: terminating portaudio failed: %w", err)
		return
	}
	return
}
func (p *PortAudio) Info() (s string) {
	// Get host APIs
	as, err := portaudio.HostApis()
	if err != nil {
		return "getting portaudio host apis failed"
	}

	// Loop through APIs
	s = "\n+ Portaudio\n"
	for idxAPI, a := range as {
		s += fmt.Sprintf("|\n+--+ Host API #%d: %s - %s\n", idxAPI, a.Name, a.Type)
		if a.DefaultInputDevice != nil {
			s += fmt.Sprintf("|  |\n|  +--+ Default input device: %s\n", a.DefaultInputDevice.Name)
		}
		if a.DefaultOutputDevice != nil {
			s += fmt.Sprintf("|  |\n|  +--+ Default output device: %s\n", a.DefaultOutputDevice.Name)
		}
		if len(a.Devices) > 0 {
			s += "|  |\n|  +--+ Devices:\n"
			for idxDevice, d := range a.Devices {
				s += fmt.Sprintf("|     |\n|     +--+ Device #%d: %s (sample rate: %.0fkHz - max input channels: %v)\n", idxDevice, d.Name, d.DefaultSampleRate, d.MaxInputChannels)
			}
		}
	}
	return
}

repository: bonedaddy/go-astibob

repo_name: bonedaddy/go-astibob


text:
package utils

const RedisConFile = "/conf/redis.yaml"

const KafkaConFile = "/conf/kafka.yaml"

const MongoConFile = "/conf/mongo.yaml"

const NewOffset = -1
const OldOffset = -2

// mongo使用表名
const (
	ServiceDiscoveryTable = "Discovery_"
)

const KafkaType = "kafka"
const SocketType = "socket"

const WebSocketType = "websocket"

repository: kinyz/KServer

repo_name: kinyz/KServer


text:
#---------------------------------------------------#
#     DEFINE C++ STANDARD                           #
#---------------------------------------------------#
function(DEFINE_CPP_STANDARD NAME_OF_TARGET VERSION_NUMBER)
    MESSAGE("Defined C++${VERSION_NUMBER} for target ${NAME_OF_TARGET}")
    # set c++14 as the used c++ standard for this library
    SET_PROPERTY(TARGET ${NAME_OF_TARGET} PROPERTY CXX_STANDARD ${VERSION_NUMBER})
    SET_PROPERTY(TARGET ${NAME_OF_TARGET} PROPERTY CXX_STANDARD_REQUIRED ON)
    IF(IOS)
        SET(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++${VERSION_NUMBER}")
        SET(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++${VERSION_NUMBER}")
    ENDIF(IOS)
endfunction()

function(DEFINE_CPP_STANDARD_AS_11 NAME_OF_TARGET)
    MESSAGE("Defined C++11 for target ${NAME_OF_TARGET}")
    # set c++14 as the used c++ standard for this library
    SET_PROPERTY(TARGET ${NAME_OF_TARGET} PROPERTY CXX_STANDARD 11)
    SET_PROPERTY(TARGET ${NAME_OF_TARGET} PROPERTY CXX_STANDARD_REQUIRED ON)
    IF(IOS)
        SET(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++11")
        SET(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++11")
    ENDIF(IOS)
endfunction()

function(DEFINE_CPP_STANDARD_AS_14 NAME_OF_TARGET)
    MESSAGE("Defined C++14 for target ${NAME_OF_TARGET}")
    # set c++14 as the used c++ standard for this library
    SET_PROPERTY(TARGET ${NAME_OF_TARGET} PROPERTY CXX_STANDARD 14)
    SET_PROPERTY(TARGET ${NAME_OF_TARGET} PROPERTY CXX_STANDARD_REQUIRED ON)
    IF(IOS)
        SET(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++14")
        SET(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++14")
    ENDIF(IOS)
endfunction()

function(DEFINE_CPP_STANDARD_AS_17 NAME_OF_TARGET)
    MESSAGE("Defined C++17 for target ${NAME_OF_TARGET}")
    # set c++17 as the used c++ standard for this library
    SET_PROPERTY(TARGET ${NAME_OF_TARGET} PROPERTY CXX_STANDARD 17)
    SET_PROPERTY(TARGET ${NAME_OF_TARGET} PROPERTY CXX_STANDARD_REQUIRED ON)
    IF(IOS)
        SET(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++17")
        SET(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++17")
    ENDIF(IOS)
endfunction()

repository: Vicomtech/video-content-description-VCD

repo_name: Vicomtech/video-content-description-VCD


text: @inproceedings{Cardoso04ICEIS,	address = {Porto, Portugal},	author = {Cardoso, Jorge},	booktitle = {First International Workshop on Computer Supported Activity Coordination (CSAC-2004), ICEIS 2004, 6th International Conference on Enterprise Information Systems},	date-added = {2018-04-25 20:02:07 +0000},	date-modified = {2018-04-25 20:02:07 +0000},	owner = {Jorge Cardoso},	pages = {3-12},	refid = {25},	timestamp = {2010.08.26},	title = {Building workflows definitions based on business cases},	webpdf = {/Papers/WP-2004-012-ICEIS-CSAC-Building-workflows-definitions-based-on-business-cases.pdf},	year = {2004}}


text:
@article{DeBofsky-2022-16S,
    title = "16S rRNA metabarcoding unearths responses of rare gut microbiome of fathead minnows exposed to benzo[a]pyrene",
    author = "DeBofsky, Abigail  and
      Xie, Yuwei  and
      Challis, Jonathan K.  and
      Ankley, Phillip J.  and
      Brinkmann, Markus  and
      Jones, Paul D.  and
      Giesy, John P.",
    journal = "Science of The Total Environment, Volume 807",
    volume = "807",
    year = "2022",
    publisher = "Elsevier BV",
    url = "https://aclanthology.org/G22-7001",
    doi = "10.1016/j.scitotenv.2021.151060",
    pages = "151060",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications


text:
package resolver

import (
	"github.com/graphql-go/graphql"
	"github.com/taiyoh/labeltile/app"
)

func initRootMutation(s *TypeStorage, container app.Container) {
	m := s.Get(GQLType("RootMutation"))
	rm := &RootMutation{container: container}
	for _, f := range []*graphql.Field{
		&graphql.Field{
			Name: "updateUser",
			Type: s.Get(GQLType("User")),
			Args: graphql.FieldConfigArgument{
				"id": &graphql.ArgumentConfig{Type: graphql.NewNonNull(graphql.ID)},
			},
			Resolve: rm.UpdateUser,
		},
	} {
		m.AddFieldConfig(f.Name, f)
	}
}

// RootMutation is field resolver aggregation for RootMutation type
type RootMutation struct {
	container app.Container
}

// UpdateUser is implementation for "updateUser" field in RootMutation type
func (t *RootMutation) UpdateUser(p graphql.ResolveParams) (interface{}, error) {
	return nil, nil
}

repository: taiyoh/labeltile

repo_name: taiyoh/labeltile


text:
//go:build windows

package win

const (
	// InitCommonControlsEx flags
	ICC_LISTVIEW_CLASSES   = 0x00000001
	ICC_TREEVIEW_CLASSES   = 0x00000002
	ICC_BAR_CLASSES        = 0x00000004
	ICC_TAB_CLASSES        = 0x00000008
	ICC_UPDOWN_CLASS       = 0x00000010
	ICC_PROGRESS_CLASS     = 0x00000020
	ICC_HOTKEY_CLASS       = 0x00000040
	ICC_ANIMATE_CLASS      = 0x00000080
	ICC_WIN95_CLASSES      = 0x000000FF
	ICC_DATE_CLASSES       = 0x00000100
	ICC_USEREX_CLASSES     = 0x00000200
	ICC_COOL_CLASSES       = 0x00000400
	ICC_INTERNET_CLASSES   = 0x00000800
	ICC_PAGESCROLLER_CLASS = 0x00001000
	ICC_NATIVEFNTCTL_CLASS = 0x00002000
	ICC_STANDARD_CLASSES   = 0x00004000
	ICC_LINK_CLASS         = 0x00008000
)

// https://docs.microsoft.com/en-us/windows/win32/api/commctrl/ns-commctrl-initcommoncontrolsex
type INITCOMMONCONTROLSEX struct {
	Size uint32
	ICC  uint32
}

//sys InitCommonControlsEx(icc *INITCOMMONCONTROLSEX) (ok bool) = comctl32.InitCommonControlsEx

repository: ncruces/zenity

repo_name: ncruces/zenity