text:
@Article{	  gmr1989,
  author	= {Goldwasser, Shafi and Micali, Silvio and Rackoff,
		  Charles},
  title		= {The Knowledge Complexity of Interactive Proof Systems},
  journal	= {SIAM Journal on Computing},
  volume	= {18},
  number	= {1},
  pages		= {186--208},
  year		= {1989},
  doi		= {10.1137/0218012},
  url		= {https://doi.org/10.1137/0218012}
}

@InProceedings{	  kilian1992,
  author	= {Kilian, Joe},
  title		= {A Note on Efficient Zero-knowledge Proofs and Arguments
		  (Extended Abstract)},
  booktitle	= {Proceedings of the Twenty-fourth Annual ACM Symposium on
		  Theory of Computing},
  series	= {STOC '92},
  year		= {1992},
  month		= {May},
  isbn		= {0-89791-511-9},
  location	= {Victoria, British Columbia, Canada},
  pages		= {723--732},
  numpages	= {10},
  url		= {https://doi.acm.org/10.1145/129712.129782},
  doi		= {10.1145/129712.129782},
  acmid		= {129782},
  publisher	= {ACM},
  address	= {New York, NY, USA}
}

@InProceedings{	  mekhl2010,
  author	= {Meiklejohn, Sarah and Erway, C. Chris and Küpçü,
		  Alptekin and Hinkle, Theodora and Lysyanskaya, Anna},
  title		= {ZKPDL: A Language-Based System for Efficient
		  Zero-Knowledge Proofs and Electronic Cash},
  booktitle	= {19th USENIX Security Symposium},
  year		= {2010},
  month		= {August},
  url		= {https://www.usenix.org/legacy/event/sec10/tech/full_papers/Meiklejohn.pdf}
}

@InProceedings{	  bcgtv2013,
  author	= {Ben-Sasson, Eli and Chiesa, Alessandro and Genkin, Daniel
		  and Tromer, Eran and Virza, Madars},
  editor	= {Canetti, Ran and Garay, Juan A.},
  title		= {SNARKs for C: Verifying Program Executions Succinctly and
		  in Zero Knowledge},
  booktitle	= {Advances in Cryptology -- CRYPTO 2013},
  year		= {2013},
  publisher	= {Springer Berlin Heidelberg},
  address	= {Berlin, Heidelberg},
  pages		= {90--108},
  isbn		= {978-3-642-40084-1}
}

@InProceedings{	  bfrsbw2013,
  author	= {Braun, Benjamin and Feldman, Ariel J. and Ren, Zuocheng
		  and Setty, Srinath and Blumberg, Andrew J. and Walfish,
		  Michael},
  title		= {Verifying Computations with State},
  booktitle	= {Proceedings of the Twenty-Fourth ACM Symposium on
		  Operating Systems Principles},
  series	= {SOSP '13},
  year		= {2013},
  month		= {November},
  isbn		= {978-1-4503-2388-8},
  location	= {Farminton, Pennsylvania},
  pages		= {341--357},
  numpages	= {17},
  url		= {https://doi.acm.org/10.1145/2517349.2522733},
  doi		= {10.1145/2517349.2522733},
  acmid		= {2522733},
  publisher	= {ACM},
  address	= {New York, NY, USA}
}

@InProceedings{	  ggpr2013,
  author	= {Gennaro, Rosario and Gentry, Craig and Parno, Bryan and
		  Raykova, Mariana},
  editor	= {Johansson, Thomas and Nguyen, Phong Q.},
  title		= {Quadratic Span Programs and Succinct NIZKs without PCPs},
  booktitle	= {Advances in Cryptology -- EUROCRYPT 2013},
  year		= {2013},
  publisher	= {Springer Berlin Heidelberg},
  address	= {Berlin, Heidelberg},
  pages		= {626--645},
  isbn		= {978-3-642-38348-9}
}

@InProceedings{	  phgr2013,
  author	= {Parno, Bryan and Howell, Jon and Gentry, Craig and
		  Raykova, Mariana},
  booktitle	= {2013 IEEE Symposium on Security and Privacy},
  title		= {Pinocchio: Nearly Practical Verifiable Computation},
  year		= {2013},
  month		= {May},
  pages		= {238--252},
  doi		= {10.1109/SP.2013.47},
  issn		= {1081-6011}
}

@InProceedings{	  bcggmtv2014,
  author	= {Ben-Sasson, Eli and Chiesa, Alessandro and Garman,
		  Christina and Green, Matthew and Miers, Ian and Tromer,
		  Eran and Virza, Madars},
  booktitle	= {2014 IEEE Symposium on Security and Privacy (SP)},
  title		= {Zerocash: Decentralized Anonymous Payments from Bitcoin},
  year		= {2014},
  month		= {May},
  pages		= {459--474},
  doi		= {10.1109/SP.2014.36},
  url		= {https://doi.ieeecomputersociety.org/10.1109/SP.2014.36},
  issn		= {1081-6011}
}

@InProceedings{	  bctv2014a,
  author	= {Ben-Sasson, Eli and Chiesa, Alessandro and Tromer, Eran
		  and Virza, Madars},
  title		= {Succinct Non-Interactive Zero Knowledge for a von Neumann
		  Architecture},
  booktitle	= {23rd USENIX Security Symposium},
  year		= {2014},
  month		= {August},
  url		= {https://www.usenix.org/conference/usenixsecurity14/technical-sessions/presentation/ben-sasson},
  isbn		= {978-1-931971-15-7}
}

@InProceedings{	  hmps2014,
  author	= {Hohenberger, Susan and Myers, Steven and Pass, Rafael and
		  shelat, abhi},
  booktitle	= {2014 IEEE Symposium on Security and Privacy},
  title		= {ANONIZE: A Large-Scale Anonymous Survey System},
  year		= {2014},
  month		= {May},
  pages		= {375--389},
  doi		= {10.1109/SP.2014.31},
  issn		= {1081-6011}
}

@InProceedings{	  bcgtv2015,
  author	= {Ben-Sasson, Eli and Chiesa, Alessandro and Green, Matthew
		  and Tromer, Eran and Virza, Madars},
  booktitle	= {2015 IEEE Symposium on Security and Privacy},
  title		= {Secure Sampling of Public Parameters for Succinct Zero
		  Knowledge Proofs},
  year		= {2015},
  month		= {May},
  pages		= {287--304},
  doi		= {10.1109/SP.2015.25},
  issn		= {1081-6011}
}

@InProceedings{	  cfhkknpz2015,
  author	= {Costello, Craig and Fournet, Cedric and Howell, Jon and
		  Kohlweiss, Markulf and Kreuter, Benjamin and Naehrig,
		  Michael and Parno, Bryan and Zahur, Samee},
  booktitle	= {2015 IEEE Symposium on Security and Privacy (SP)},
  title		= {Geppetto: Versatile Verifiable Computation},
  year		= {2015},
  month		= {May},
  volume	= {00},
  number	= {},
  pages		= {253--270},
  doi		= {10.1109/SP.2015.23},
  url		= {https://doi.ieeecomputersociety.org/10.1109/SP.2015.23},
  issn		= {1081-6011}
}

@Misc{		  cryptoeprint:2015:1093,
  author	= {Kosba, Ahmed and Zhao, Zhichao and Miller, Andrew and
		  Qian, Yi and Chan, Hubert and Papamanthou, Charalampos and
		  Pass, Rafael and shelat, abhi and Shi, Elaine},
  title		= {C$\emptyset$C$\emptyset$: A Framework for Building
		  Composable Zero-Knowledge Proofs},
  howpublished	= {Cryptology ePrint Archive, Report 2015/1093},
  year		= {2015},
  url		= {https://eprint.iacr.org/2015/1093}
}

@InProceedings{	  ctv2015,
  author	= {Chiesa, Alessandro and Tromer, Eran and Virza, Madars},
  editor	= {Oswald, Elisabeth and Fischlin, Marc},
  title		= {Cluster Computing in Zero Knowledge},
  booktitle	= {Advances in Cryptology - EUROCRYPT 2015},
  year		= {2015},
  publisher	= {Springer Berlin Heidelberg},
  address	= {Berlin, Heidelberg},
  pages		= {371--403},
  isbn		= {978-3-662-46803-6}
}

@InProceedings{	  wsrbw2015,
  author	= {Wahby, Riad S. and Setty, Srinath and Ren, Zuocheng and
		  Blumberg, Andrew J. and Walfish, Michael},
  booktitle	= {NDSS '15},
  title		= {Efficient RAM and control flow in verifiable outsourced
		  computation},
  year		= {2015},
  month		= {February},
  doi		= {10.14722/ndss.2015.23097},
  isbn		= {1-891562-38-X},
  url		= {https://dx.doi.org/10.14722/ndss.2015.23097}
}

@InProceedings{	  bccgp2016,
  author	= {Bootle, Jonathan and Cerulli, Andrea and Chaidos, Pyrros
		  and Groth, Jens and Petit, Christophe},
  editor	= {Fischlin, Marc and Coron, Jean-S{\'e}bastien},
  title		= {Efficient Zero-Knowledge Arguments for Arithmetic Circuits
		  in the Discrete Log Setting},
  booktitle	= {Advances in Cryptology -- EUROCRYPT 2016},
  year		= {2016},
  publisher	= {Springer Berlin Heidelberg},
  address	= {Berlin, Heidelberg},
  pages		= {327--357},
  isbn		= {978-3-662-49896-5}
}

@InProceedings{	  cgm2016,
  author	= {Chase, Melissa and Ganesh, Chaya and Mohassel, Payman},
  editor	= {Robshaw, Matthew and Katz, Jonathan},
  title		= {Efficient Zero-Knowledge Proof of Algebraic and
		  Non-Algebraic Statements with Applications to Privacy
		  Preserving Credentials},
  booktitle	= {Advances in Cryptology -- CRYPTO 2016},
  year		= {2016},
  publisher	= {Springer Berlin Heidelberg},
  address	= {Berlin, Heidelberg},
  pages		= {499--530},
  isbn		= {978-3-662-53015-3}
}

@InProceedings{	  gmo2016,
  author	= {Giacomelli, Irene and Madsen, Jesper and Orlandi,
		  Claudio},
  title		= {ZKBoo: Faster Zero-Knowledge for Boolean Circuits},
  booktitle	= {25rd USENIX Security Symposium},
  year		= {2016},
  month		= {August},
  url		= {https://www.usenix.org/conference/usenixsecurity16/technical-sessions/presentation/giacomelli},
  isbn		= {978-1-931971-32-4}
}

@InProceedings{	  groth2016,
  author	= {Groth, Jens},
  editor	= {Fischlin, Marc and Coron, Jean-S{\'e}bastien},
  title		= {On the Size of Pairing-Based Non-interactive Arguments},
  booktitle	= {Advances in Cryptology -- EUROCRYPT 2016},
  year		= {2016},
  publisher	= {Springer Berlin Heidelberg},
  address	= {Berlin, Heidelberg},
  pages		= {305--326},
  isbn		= {978-3-662-49896-5}
}

@InProceedings{	  ahiv2017,
  author	= {Ames, Scott and Hazay, Carmit and Ishai, Yuval and
		  Venkitasubramaniam, Muthuramakrishnan},
  title		= {Ligero: Lightweight Sublinear Arguments Without a Trusted
		  Setup},
  booktitle	= {Proceedings of the 2017 ACM SIGSAC Conference on Computer
		  and Communications Security},
  series	= {CCS '17},
  year		= {2017},
  isbn		= {978-1-4503-4946-8},
  location	= {Dallas, Texas, USA},
  pages		= {2087--2104},
  numpages	= {18},
  url		= {https://doi.acm.org/10.1145/3133956.3134104},
  doi		= {10.1145/3133956.3134104},
  acmid		= {3134104},
  publisher	= {ACM},
  address	= {New York, NY, USA}
}

@Article{	  bctv2017,
  author	= {Ben-Sasson, Eli and Chiesa, Alessandro and Tromer, Eran
		  and Virza, Madars},
  title		= {Scalable Zero Knowledge Via Cycles of Elliptic Curves},
  journal	= {Algorithmica},
  year		= {2017},
  month		= {Dec},
  day		= {01},
  volume	= {79},
  number	= {4},
  pages		= {1102--1160},
  issn		= {1432-0541},
  doi		= {10.1007/s00453-016-0221-0},
  url		= {https://doi.org/10.1007/s00453-016-0221-0}
}

@InProceedings{	  cdgorrsz2017,
  author	= {Chase, Melissa and Derler, David and Goldfeder, Steven and
		  Orlandi, Claudio and Ramacher, Sebastian and Rechberger,
		  Christian and Slamanig, Daniel and Zaverucha, Greg},
  title		= {Post-Quantum Zero-Knowledge and Signatures from
		  Symmetric-Key Primitives},
  booktitle	= {Proceedings of the 2017 ACM SIGSAC Conference on Computer
		  and Communications Security},
  series	= {CCS '17},
  year		= {2017},
  isbn		= {978-1-4503-4946-8},
  location	= {Dallas, Texas, USA},
  pages		= {1825--1842},
  numpages	= {18},
  url		= {https://doi.acm.org/10.1145/3133956.3133997},
  doi		= {10.1145/3133956.3133997},
  acmid		= {3133997},
  publisher	= {ACM},
  address	= {New York, NY, USA}
}

@Misc{		  cryptoeprint:2017:1050,
  author	= {Bowe, Sean and Gabizon, Ariel and Miers, Ian},
  title		= {Scalable Multi-party Computation for zk-SNARK Parameters
		  in the Random Beacon Model},
  howpublished	= {Cryptology ePrint Archive, Report 2017/1050},
  year		= {2017},
  url		= {https://eprint.iacr.org/2017/1050}
}

@Misc{		  cryptoeprint:2017:602,
  author	= {Bowe, Sean and Gabizon, Ariel and Green, Matthew D.},
  title		= {A multi-party protocol for constructing the public
		  parameters of the Pinocchio zk-SNARK},
  howpublished	= {Cryptology ePrint Archive, Report 2017/602},
  year		= {2017},
  url		= {https://eprint.iacr.org/2017/602}
}

@InProceedings{	  gm2017,
  author	= {Groth, Jens and Maller, Mary},
  editor	= {Katz, Jonathan and Shacham, Hovav},
  title		= {Snarky Signatures: Minimal Signatures of Knowledge from
		  Simulation-Extractable SNARKs},
  booktitle	= {Advances in Cryptology -- CRYPTO 2017},
  year		= {2017},
  publisher	= {Springer International Publishing},
  address	= {Cham},
  pages		= {581--612},
  isbn		= {978-3-319-63715-0}
}

@InProceedings{	  agm2018,
  author	= {Agrawal, Shashank and Ganesh, Chaya and Mohassel, Payman},
  editor	= {Shacham, Hovav and Boldyreva, Alexandra},
  title		= {Non-Interactive Zero-Knowledge Proofs for Composite
		  Statements},
  booktitle	= {Advances in Cryptology -- CRYPTO 2018},
  year		= {2018},
  publisher	= {Springer International Publishing},
  address	= {Cham},
  pages		= {643--673},
  isbn		= {978-3-319-96878-0}
}

@InProceedings{	  bbbpwm2018,
  author	= {Bünz, Benedikt and Bootle, Jonathan and Boneh, Dan and
		  Poelstra, Andrew and Wuille, Pieter and Maxwell, Greg},
  booktitle	= {2018 IEEE Symposium on Security and Privacy (SP)},
  title		= {Bulletproofs: Short Proofs for Confidential Transactions
		  and More},
  year		= {2018},
  month		= {May},
  pages		= {319--338},
  doi		= {10.1109/SP.2018.00020},
  url		= {https://doi.ieeecomputersociety.org/10.1109/SP.2018.00020},
  issn		= {2375-1207}
}

@Misc{		  cryptoeprint:2018:046,
  author	= {Ben-Sasson, Eli and Bentov, Iddo and Horesh, Yinon and
		  Riabzev, Michael},
  title		= {Scalable, transparent, and post-quantum secure
		  computational integrity},
  howpublished	= {Cryptology ePrint Archive, Report 2018/046},
  year		= {2018},
  url		= {https://eprint.iacr.org/2018/046}
}

@Misc{		  cryptoeprint:2018:176,
  author	= {Kluczniak, Kamil and Au, Man Ho},
  title		= {Fine-Tuning Decentralized Anonymous Payment Systems based
		  on Arguments for Arithmetic Circuit Satisfiability},
  howpublished	= {Cryptology ePrint Archive, Report 2018/176},
  year		= {2018},
  url		= {https://eprint.iacr.org/2018/176}
}

@Misc{		  cryptoeprint:2018:187,
  author	= {Bowe, Sean and Gabizon, Ariel},
  title		= {Making Groth's zk-SNARK Simulation Extractable in the
		  Random Oracle Model},
  howpublished	= {Cryptology ePrint Archive, Report 2018/187},
  year		= {2018},
  url		= {https://eprint.iacr.org/2018/187}
}

@InProceedings{	  gkmmm2018,
  author	= {Groth, Jens and Kohlweiss, Markulf and Maller, Mary and
		  Meiklejohn, Sarah and Miers, Ian},
  editor	= {Shacham, Hovav and Boldyreva, Alexandra},
  title		= {Updatable and Universal Common Reference Strings with
		  Applications to zk-SNARKs},
  booktitle	= {Advances in Cryptology -- CRYPTO 2018},
  year		= {2018},
  publisher	= {Springer International Publishing},
  address	= {Cham},
  pages		= {698--728},
  isbn		= {978-3-319-96878-0}
}

@InProceedings{	  kps18,
  author	= {Kosba, Ahmed and Papamanthou, Charalampos and Shi,
		  Elaine},
  booktitle	= {2018 IEEE Symposium on Security and Privacy (SP)},
  title		= {xJsnark: A Framework for Efficient Verifiable
		  Computation},
  year		= {2018},
  month		= {May},
  pages		= {543--560},
  doi		= {10.1109/SP.2018.00018},
  url		= {https://doi.ieeecomputersociety.org/10.1109/SP.2018.00018},
  issn		= {2375-1207}
}

@InProceedings{	  sml2018,
  author	= {Stewart, Gordon and Merten, Samuel and Leland, Logan},
  editor	= {Calimeri, Francesco and Hamlen, Kevin and Leone, Nicola},
  title		= {Sn{\aa}rkl: Somewhat Practical, Pretty Much Declarative
		  Verifiable Computing in Haskell},
  booktitle	= {Practical Aspects of Declarative Languages},
  year		= {2018},
  publisher	= {Springer International Publishing},
  address	= {Cham},
  pages		= {36--52},
  isbn		= {978-3-319-73305-0}
}

@Unpublished{	  specification:zcash2018b30,
  author	= {Hopwood, Daira and Bowe, Sean and Hornby, Taylor and
		  Wilcox, Nathan},
  title		= {Zcash Protocol Specification, Version 2018.0-beta-30
		  [Overwinter+Sapling]},
  year		= {2018},
  month		= {September},
  note		= {Defines the Sprout and Sapling circuits as deployed on the
		  Zcash network.},
  url		= {https://github.com/zcash/zips/blob/master/protocol/protocol.pdf}
}

@InProceedings{	  wtstw2018,
  author	= {Wahby, Riad S. and Tzialla, Ioanna and shelat, abhi and
		  Thaler, Justin and Walfish, Michael},
  booktitle	= {2018 IEEE Symposium on Security and Privacy (SP)},
  title		= {Doubly-Efficient zkSNARKs Without Trusted Setup},
  year		= {2018},
  month		= {May},
  pages		= {926--943},
  doi		= {10.1109/SP.2018.00060},
  issn		= {2375-1207}
}


text:
.jumbotron {
	margin-bottom: 0px;
}

.jumbotron p{
text-align: center;
font-size: 24px;
padding-right: 45px;
}
body {
	font-family: 'Lato', Calibri, Arial, sans-serif;
}
.jumbotron hr{
	border-top: 1px solid black;
}

.jumbotron img{
	width: 50%;
	height: 50%;
}

#one img{
  width: auto;
  height : auto;
  max-width: 100%;
  max-height: 100%
}

#one{
	padding: 0px;
}
.col-md-6{
	padding: 0px;
}
.col-md-6 img{
	width: auto;
  height : auto;
  max-width: 100%;
  max-height: 100%
}

#other h1{
	text-align: center;
}

#text h1{
	text-align: center;

}

#text p{
	font-size: 17px;
	text-align: left;
}

.container{
	text-align: center;
}

#contact .icon {
	width: 40px;
	height: 40px;
}

.form-control{
	width: 50%;
}
.container textarea{
	margin-left: 25%;
}

html, body {
        height: 100%;
        margin: 0;
        padding: 0;
}

#map{
	height: 40%;
}

.navbar-brand{
	padding: 0px;
}

#other h1{

	color: #b3b9bf;
}

license: MIT

license_type: permissive

branch_name: refs/heads/master

extension: css


text:
@book{weaklearnability,
  author    = {R. E. Schapire},
  title     = {The strength of weak learnability},
  publisher = {Kluwer Academic Publishers},
  year      = 1990,
  note      = {p. 197-227},
}
@MISC{boosting,
    author = {Robert E. Schapire and Yoav Freund and Peter Bartlett and Wee Sun Lee},
    title = {Boosting the Margin: A New Explanation for the Effectiveness of Voting Methods},
    year = {1997}
}

@book{ensembleML,
  author    = {C.Zhang and Y.MA},
  title     = {Ensemble Machine Learning ,Methods and Applications},
  publisher = {Landon: Springer},
  year      = 2012,
  note      = {pp.254-270},
}

@article{UNet,
  author    = {Olaf Ronneberger and
               Philipp Fischer and
               Thomas Brox},
  title     = {U-Net: Convolutional Networks for Biomedical Image Segmentation},
  journal   = {CoRR},
  volume    = {abs/1505.04597},
  year      = {2015},
  url       = {http://arxiv.org/abs/1505.04597},
  archivePrefix = {arXiv},
  eprint    = {1505.04597},
  timestamp = {Mon, 13 Aug 2018 16:46:52 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/RonnebergerFB15},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@ARTICLE{bidirectionalrecurrent,
    author = {Mike Schuster and Kuldip K. Paliwal and A. General},
    title = {Bidirectional recurrent neural networks},
    journal = {IEEE Transactions on Signal Processing},
    year = {1997}
}

@article{LSTM,
 author = {Hochreiter, Sepp and Schmidhuber, J\"{u}rgen},
 title = {Long Short-Term Memory},
 journal = {Neural Comput.},
 issue_date = {November 15, 1997},
 volume = {9},
 number = {8},
 month = nov,
 year = {1997},
 issn = {0899-7667},
 pages = {1735--1780},
 numpages = {46},
 url = {http://dx.doi.org/10.1162/neco.1997.9.8.1735},
 doi = {10.1162/neco.1997.9.8.1735},
 acmid = {1246450},
 publisher = {MIT Press},
 address = {Cambridge, MA, USA},
}

@inproceedings{HofferHS17,
  author    = {Elad Hoffer and
               Itay Hubara and
               Daniel Soudry},
  title     = {Train longer, generalize better: closing the generalization gap in
               large batch training of neural networks},
  booktitle = {Advances in Neural Information Processing Systems 30: Annual Conference
               on Neural Information Processing Systems 2017, 4-9 December 2017,
               Long Beach, CA, {USA}},
  pages     = {1729--1739},
  year      = {2017},
  timestamp = {Mon, 27 Nov 2017 12:38:16 +0100},
  biburl    = {https://dblp.org/rec/bib/conf/nips/HofferHS17},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@inproceedings{GlorotB10,
  author    = {Xavier Glorot and
               Yoshua Bengio},
  title     = {Understanding the difficulty of training deep feedforward neural networks},
  booktitle = {Proceedings of the Thirteenth International Conference on Artificial
               Intelligence and Statistics, {AISTATS} 2010, Chia Laguna Resort, Sardinia,
               Italy, May 13-15, 2010},
  pages     = {249--256},
  year      = {2010},
  url       = {http://www.jmlr.org/proceedings/papers/v9/glorot10a.html},
  timestamp = {Thu, 11 Sep 2014 07:28:56 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/jmlr/GlorotB10},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{Adam,
  author    = {Diederik P. Kingma and
               Jimmy Ba},
  title     = {Adam: {A} Method for Stochastic Optimization},
  journal   = {CoRR},
  volume    = {abs/1412.6980},
  year      = {2014},
  url       = {http://arxiv.org/abs/1412.6980},
  archivePrefix = {arXiv},
  eprint    = {1412.6980},
  timestamp = {Mon, 13 Aug 2018 16:47:35 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/KingmaB14},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{UTD-MHAD,
author = {Chen, Chen},
year = {2015},
month = {09},
pages = {},
title = {UTD-MHAD: A Multimodal Dataset for Human Action Recognition Utilizing a Depth Camera and a Wearable Inertial Sensor},
doi = {10.1109/ICIP.2015.7350781}
}

@INPROCEEDINGS{1570899,
author={P. Dollar and V. Rabaud and G. Cottrell and S. Belongie},
booktitle={2005 IEEE International Workshop on Visual Surveillance and Performance Evaluation of Tracking and Surveillance},
title={Behavior recognition via sparse spatio-temporal features},
year={2005},
volume={},
number={},
pages={65-72},
keywords={image recognition;object detection;behavior recognition;spatio-temporal features;object recognition;Object recognition;Object detection;Detectors;Mice;Computer vision;Robustness;Spatiotemporal phenomena;Video sequences;Prototypes;Computer science},
doi={10.1109/VSPETS.2005.1570899},
ISSN={},
month={Oct}
}

@INPROCEEDINGS{1238378,
author={Laptev and Lindeberg},
booktitle={Proceedings Ninth IEEE International Conference on Computer Vision},
title={Space-time interest points},
year={2003},
volume={},
number={},
pages={432-439 vol.1},
keywords={image motion analysis;image representation;spatiotemporal phenomena;computer vision;feature extraction;image pattern representation;spatial interest point;spatio-temporal domain;video data representation;spatio-temporal event detection;scale-invariant spatio-temporal descriptor;human motion analysis;Event detection;Computer vision;Image motion analysis;Motion analysis;Layout;Indexing;Optical computing;Spatiotemporal phenomena;Acceleration;Videoconference},
doi={10.1109/ICCV.2003.1238378},
ISSN={},
month={Oct}
}

@INPROCEEDINGS{5995407,
author={H. Wang and A. Kläser and C. Schmid and C. Liu},
booktitle={CVPR 2011},
title={Action recognition by dense trajectories},
year={2011},
volume={},
number={},
pages={3169-3176},
keywords={cameras;feature extraction;image classification;image motion analysis;image sampling;image sequences;action recognition;dense trajectories;feature trajectories;KLT tracker;SIFT descriptor matching;feature extraction;image classification;optical flow field;motion boundary histograms;camera motion;uncontrolled realistic videos;bag-of-features approach;Trajectory;Videos;Tracking;Optical imaging;Training;Feature extraction;Cameras},
doi={10.1109/CVPR.2011.5995407},
ISSN={1063-6919},
month={June}
}

@ARTICLE{4487086,
author={T. Choudhury and G. Borriello and S. Consolvo and D. Haehnel and B. Harrison and B. Hemingway and J. Hightower and P. ". Klasnja and K. Koscher and A. LaMarca and J. A. Landay and L. LeGrand and J. Lester and A. Rahimi and A. Rea and D. Wyatt},
journal={IEEE Pervasive Computing},
title={The Mobile Sensing Platform: An Embedded Activity Recognition System},
year={2008},
volume={7},
number={2},
pages={32-41},
keywords={sensors;ubiquitous computing;mobile sensing;embedded activity recognition system;activity-aware systems;user interfaces;smart environments;surveillance;emergency response;military missions;body-worn sensors;healthcare applications;wearable systems;real-time activity information;activity recognition systems;Accelerometers;Ubiquitous computing;Privacy;Medical services;Protection;Robustness;Software design;Algorithm design and analysis;Software algorithms;Pervasive computing;activity recognition;embedded systems;machine learning;wearable computers},
doi={10.1109/MPRV.2008.39},
ISSN={1536-1268},
month={April}
}

@INPROCEEDINGS{7881728,
author={Song-Mi Lee and Sang Min Yoon and Heeryon Cho},
booktitle={2017 IEEE International Conference on Big Data and Smart Computing (BigComp)},
title={Human activity recognition from accelerometer data using Convolutional Neural Network},
year={2017},
volume={},
number={},
pages={131-134},
keywords={accelerometers;convolution;gait analysis;neural nets;human activity recognition;1D convolutional neural network;triaxial accelerometer data;walking;running;staying still;smartphone accelerometer sensor;vector magnitude;ternary activity recognition performance;baseline random forest approach;Activity recognition;Accelerometers;Intelligent sensors;Hidden Markov models;Smart phones;Time series analysis;human activity recognition;convolutional neural network;3D accelerometer data;random forest},
doi={10.1109/BIGCOMP.2017.7881728},
ISSN={2375-9356},
month={Feb}
}
@article{abs-1106-0257,
  author    = {Richard Maclin and
               David W. Opitz},
  title     = {Popular Ensemble Methods: An Empirical Study},
  journal   = {CoRR},
  volume    = {abs/1106.0257},
  year      = {2011},
  url       = {http://arxiv.org/abs/1106.0257},
  archivePrefix = {arXiv},
  eprint    = {1106.0257},
  timestamp = {Mon, 13 Aug 2018 16:47:18 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/abs-1106-0257},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@InProceedings{KarpathyCVPR14,
author = {Andrej Karpathy and George Toderici and Sanketh Shetty and Thomas Leung and Rahul Sukthankar and Li Fei-Fei},
title = {Large-scale Video Classification with Convolutional Neural Networks},
booktitle = {CVPR},
OPTyear = {2014}
}

@article{SimonyanZ14,
  author    = {Karen Simonyan and
               Andrew Zisserman},
  title     = {Two-Stream Convolutional Networks for Action Recognition in Videos},
  journal   = {CoRR},
  volume    = {abs/1406.2199},
  year      = {2014},
  url       = {http://arxiv.org/abs/1406.2199},
  archivePrefix = {arXiv},
  eprint    = {1406.2199},
  timestamp = {Mon, 13 Aug 2018 16:47:39 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/SimonyanZ14},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{DonahueHGRVSD14,
  author    = {Jeff Donahue and
               Lisa Anne Hendricks and
               Sergio Guadarrama and
               Marcus Rohrbach and
               Subhashini Venugopalan and
               Kate Saenko and
               Trevor Darrell},
  title     = {Long-term Recurrent Convolutional Networks for Visual Recognition
               and Description},
  journal   = {CoRR},
  volume    = {abs/1411.4389},
  year      = {2014},
  url       = {http://arxiv.org/abs/1411.4389},
  archivePrefix = {arXiv},
  eprint    = {1411.4389},
  timestamp = {Mon, 13 Aug 2018 16:46:59 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/DonahueHGRVSD14},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{TranBFTP14,
  author    = {Du Tran and
               Lubomir D. Bourdev and
               Rob Fergus and
               Lorenzo Torresani and
               Manohar Paluri},
  title     = {{C3D:} Generic Features for Video Analysis},
  journal   = {CoRR},
  volume    = {abs/1412.0767},
  year      = {2014},
  url       = {http://arxiv.org/abs/1412.0767},
  archivePrefix = {arXiv},
  eprint    = {1412.0767},
  timestamp = {Mon, 13 Aug 2018 16:49:14 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/TranBFTP14},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{YaoTCBPLC,
   author = {{Yao}, L. and {Torabi}, A. and {Cho}, K. and {Ballas}, N. and
	{Pal}, C. and {Larochelle}, H. and {Courville}, A.},
    title = "{Describing Videos by Exploiting Temporal Structure}",
  journal = {ArXiv e-prints},
archivePrefix = "arXiv",
   eprint = {1502.08029},
 primaryClass = "stat.ML",
 keywords = {Statistics - Machine Learning, Computer Science - Artificial Intelligence, Computer Science - Computation and Language, Computer Science - Computer Vision and Pattern Recognition, Computer Science - Machine Learning},
     year = 2015,
    month = feb,
   adsurl = {http://adsabs.harvard.edu/abs/2015arXiv150208029Y},
  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}

@article{FeichtenhoferPZ16,
  author    = {Christoph Feichtenhofer and
               Axel Pinz and
               Andrew Zisserman},
  title     = {Convolutional Two-Stream Network Fusion for Video Action Recognition},
  journal   = {CoRR},
  volume    = {abs/1604.06573},
  year      = {2016},
  url       = {http://arxiv.org/abs/1604.06573},
  archivePrefix = {arXiv},
  eprint    = {1604.06573},
  timestamp = {Mon, 13 Aug 2018 16:45:57 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/FeichtenhoferPZ16},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{WangXW0LTG16,
  author    = {Limin Wang and
               Yuanjun Xiong and
               Zhe Wang and
               Yu Qiao and
               Dahua Lin and
               Xiaoou Tang and
               Luc Van Gool},
  title     = {Temporal Segment Networks: Towards Good Practices for Deep Action
               Recognition},
  journal   = {CoRR},
  volume    = {abs/1608.00859},
  year      = {2016},
  url       = {http://arxiv.org/abs/1608.00859},
  archivePrefix = {arXiv},
  eprint    = {1608.00859},
  timestamp = {Mon, 13 Aug 2018 16:47:46 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/WangXW0LTG16},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{GirdharRGSR17,
  author    = {Rohit Girdhar and
               Deva Ramanan and
               Abhinav Gupta and
               Josef Sivic and
               Bryan C. Russell},
  title     = {ActionVLAD: Learning spatio-temporal aggregation for action classification},
  journal   = {CoRR},
  volume    = {abs/1704.02895},
  year      = {2017},
  url       = {http://arxiv.org/abs/1704.02895},
  archivePrefix = {arXiv},
  eprint    = {1704.02895},
  timestamp = {Mon, 13 Aug 2018 16:49:12 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/GirdharRGSR17},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}
@article{ZhuLNH17a,
  author    = {Yi Zhu and
               Zhen{-}Zhong Lan and
               Shawn D. Newsam and
               Alexander G. Hauptmann},
  title     = {Hidden Two-Stream Convolutional Networks for Action Recognition},
  journal   = {CoRR},
  volume    = {abs/1704.00389},
  year      = {2017},
  url       = {http://arxiv.org/abs/1704.00389},
  archivePrefix = {arXiv},
  eprint    = {1704.00389},
  timestamp = {Mon, 13 Aug 2018 16:47:37 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/ZhuLNH17a},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{CarreiraZ17,
  author    = {Jo{\~{a}}o Carreira and
               Andrew Zisserman},
  title     = {Quo Vadis, Action Recognition? {A} New Model and the Kinetics Dataset},
  journal   = {CoRR},
  volume    = {abs/1705.07750},
  year      = {2017},
  url       = {http://arxiv.org/abs/1705.07750},
  archivePrefix = {arXiv},
  eprint    = {1705.07750},
  timestamp = {Mon, 13 Aug 2018 16:47:23 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/CarreiraZ17},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{AliMVAMRL,
  author    = {Ali Diba and
               Mohsen Fayyaz and
               Vivek Sharma and
               Amir Hossein Karami and
               Mohammad Mahdi Arzani and
               Rahman Yousefzadeh and
               Luc Van Gool},
  title     = {Temporal 3D ConvNets: New Architecture and Transfer Learning for Video
               Classification},
  journal   = {CoRR},
  volume    = {abs/1711.08200},
  year      = {2017},
  url       = {http://arxiv.org/abs/1711.08200},
  archivePrefix = {arXiv},
  eprint    = {1711.08200},
  timestamp = {Mon, 13 Aug 2018 16:48:57 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/abs-1711-08200},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

extension: bib


text:
% This file was created with JabRef 2.10.
% Encoding: UTF-8

@Article{antonietti2016,
  Title                    = {Spiking neural network with distributed plasticity reproduces cerebellar learning in eye blink conditioning paradigms},
  Author                   = {Antonietti, Alberto and Casellato, Claudia and Garrido, Jes{\'u}s A and Luque, Niceto R and Naveros, Francisco and Ros, Eduardo and D’Angelo, Egidio and Pedrocchi, Alessandra},
  Journal                  = {IEEE Transactions on Biomedical Engineering},
  Year                     = {2016},
  Number                   = {1},
  Pages                    = {210--219},
  Volume                   = {63},

  Publisher                = {IEEE}
}

repository: EduardoRosLab/neurorobotics-website

repo_name: EduardoRosLab/neurorobotics-website


text:
DESCRIPTION="Example helloworld from eclabs"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"
#SRC_URI = "file://hello.c"
SRC_URI= "git://github.com/eclabs007/udemy-example.git;protocol=https"
SRCREV = "${AUTOREV}"

S = "${WORKDIR}/git/"
do_compile(){
				${CC} hello.c -o hello ${LDFLAGS}
}

do_install(){
			install -d ${D}${bindir}
			install -m 0777 hello   ${D}${bindir}/
}

repository: gylmd/Yocto-Udemy

repo_name: gylmd/Yocto-Udemy

extension: bb


text:
LICENSE = "nokia"

# This is proprietary software in Chinook, so we have to stay with the last released
# free version.
SRC_URI = "http://repository.maemo.org/pool/bora/free/source/${PN}_${PV}-10.tar.gz"

inherit autotools pkgconfig

do_stage() {
  autotools_stage_all
}


text:
// Copyright © 2019 The Things Network Foundation, The Things Industries B.V.
//
// 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 util

import (
	"encoding"
	"encoding/hex"
	"fmt"
	"reflect"
	"sort"
	"strings"
	"time"

	"github.com/gogo/protobuf/proto"
	"github.com/gogo/protobuf/types"
	"github.com/spf13/pflag"
	"go.thethings.network/lorawan-stack/v3/pkg/errors"
	"go.thethings.network/lorawan-stack/v3/pkg/ttnpb"
)

// DeprecateFlag deprecates a CLI flag.
func DeprecateFlag(flagSet *pflag.FlagSet, old string, new string) {
	if newFlag := flagSet.Lookup(new); newFlag != nil {
		deprecated := *newFlag
		deprecated.Name = old
		deprecated.Usage = strings.Replace(deprecated.Usage, old, new, -1)
		deprecated.Deprecated = fmt.Sprintf("use the %s flag", new)
		deprecated.Hidden = true
		flagSet.AddFlag(&deprecated)
	}
}

// ForwardFlag forwards the flag value of old to new if new is not set while old is.
func ForwardFlag(flagSet *pflag.FlagSet, old string, new string) {
	if oldFlag := flagSet.Lookup(old); oldFlag != nil && oldFlag.Changed {
		if newFlag := flagSet.Lookup(new); newFlag != nil && !newFlag.Changed {
			flagSet.Set(new, oldFlag.Value.String())
		}
	}
}

var (
	toDash       = strings.NewReplacer("_", "-")
	toUnderscore = strings.NewReplacer("-", "_")
)

// NormalizePaths converts arguments to field mask paths, replacing '-' with '_'
func NormalizePaths(paths []string) []string {
	normalized := make([]string, len(paths))
	for i, path := range paths {
		normalized[i] = toUnderscore.Replace(path)
	}
	return normalized
}

func NormalizeFlags(f *pflag.FlagSet, name string) pflag.NormalizedName {
	return pflag.NormalizedName(toDash.Replace(name))
}

func SelectFieldMask(cmdFlags *pflag.FlagSet, fieldMaskFlags ...*pflag.FlagSet) (paths []string) {
	if all, _ := cmdFlags.GetBool("all"); all {
		for _, fieldMaskFlags := range fieldMaskFlags {
			fieldMaskFlags.VisitAll(func(flag *pflag.Flag) {
				paths = append(paths, toUnderscore.Replace(flag.Name))
			})
		}
		return
	}
	cmdFlags.Visit(func(flag *pflag.Flag) {
		flagName := toUnderscore.Replace(flag.Name)
		for _, fieldMaskFlags := range fieldMaskFlags {
			if b, err := fieldMaskFlags.GetBool(flagName); err == nil && b {
				paths = append(paths, flagName)
				return
			}
		}
	})
	return
}

func UpdateFieldMask(cmdFlags *pflag.FlagSet, fieldMaskFlags ...*pflag.FlagSet) (paths []string) {
	cmdFlags.Visit(func(flag *pflag.Flag) {
		flagName := toUnderscore.Replace(flag.Name)
		for _, fieldMaskFlags := range fieldMaskFlags {
			if fieldMaskFlags.Lookup(flagName) != nil {
				paths = append(paths, flagName)
				return
			}
		}
	})
	return
}

func FieldFlags(v interface{}, prefix ...string) *pflag.FlagSet {
	t := reflect.Indirect(reflect.ValueOf(v)).Type()
	return fieldMaskFlags(prefix, t, false)
}

func FieldMaskFlags(v interface{}, prefix ...string) *pflag.FlagSet {
	t := reflect.Indirect(reflect.ValueOf(v)).Type()
	return fieldMaskFlags(prefix, t, true)
}

func isStopType(t reflect.Type, maskOnly bool) bool {
	switch t.PkgPath() {
	case "github.com/gogo/protobuf/types":
		switch t.Name() {
		case
			// Struct is a standalone type and should not be parsed further for field mask purposes.
			"Struct":
			return true
		}
	}
	return false
}

func isAtomicType(t reflect.Type, maskOnly bool) bool {
	switch t.PkgPath() {
	case "time":
		switch t.Name() {
		case "Time", "Duration":
			return true
		}
	case "github.com/gogo/protobuf/types":
		switch t.Name() {
		case
			"BoolValue",
			"BytesValue",
			"DoubleValue",
			"FloatValue",
			"Int32Value",
			"Int64Value",
			"StringValue",
			"UInt32Value",
			"UInt64Value":
			return true
		}
	case "go.thethings.network/lorawan-stack/v3/pkg/ttnpb":
		switch t.Name() {
		case
			"ADRAckDelayExponentValue",
			"ADRAckLimitExponentValue",
			"AggregatedDutyCycleValue",
			"DataRateIndexValue",
			"GatewayAntennaIdentifiers",
			"Picture",
			"PingSlotPeriodValue",
			"RxDelayValue":
			return true
		}
	}
	return false
}

func isSelectableField(name string) bool {
	switch name {
	case "created_at", "updated_at", "ids":
		return false
	}
	return true
}

func isSettableField(name string) bool {
	switch name {
	case "attributes", "contact_info", "password_updated_at", "temporary_password_created_at",
		"temporary_password_expires_at", "antennas", "profile_picture":
		return false
	}
	return true
}

func enumValues(t reflect.Type) []string {
	if t.PkgPath() == "go.thethings.network/lorawan-stack/v3/pkg/ttnpb" {
		valueMap := make(map[string]int32)
		implementsStringer := t.Implements(reflect.TypeOf((*fmt.Stringer)(nil)).Elem())
		for s, v := range proto.EnumValueMap(fmt.Sprintf("ttn.lorawan.v3.%s", t.Name())) {
			valueMap[s] = v
			if implementsStringer {
				// If the enum implements Stringer, then the String might be different than the official name.
				rv := reflect.New(t).Elem()
				rv.SetInt(int64(v))
				valueMap[rv.Interface().(fmt.Stringer).String()] = v
			}
		}
		values := make([]string, 0, len(valueMap))
		for value := range valueMap {
			values = append(values, value)
		}
		sort.Strings(values)
		return values
	}
	return nil
}

func unwrapLoRaWANEnumType(typeName string) string {
	return fmt.Sprintf("ttn.lorawan.v3.%s", strings.TrimSuffix(strings.TrimPrefix(typeName, ""), "Value"))
}

func addField(fs *pflag.FlagSet, name string, t reflect.Type, maskOnly bool) {
	if maskOnly {
		if t.Kind() == reflect.Struct && !isAtomicType(t, maskOnly) {
			fs.Bool(name, false, fmt.Sprintf("select the %s field and all allowed sub-fields", name))
			return
		}
		fs.Bool(name, false, fmt.Sprintf("select the %s field", name))
		return
	}
	if t.Kind() == reflect.Struct && !isAtomicType(t, maskOnly) {
		return
	}

	switch t.PkgPath() {
	case "time":
		switch t.Name() {
		case "Time":
			fs.String(name, "", "(YYYY-MM-DDTHH:MM:SSZ)")
			return
		case "Duration":
			fs.Duration(name, 0, "(1h2m3s)")
			return
		}

	case "github.com/gogo/protobuf/types":
		switch t.Name() {
		case "DoubleValue":
			fs.Float64(name, 0, "")
			return
		case "FloatValue":
			fs.Float32(name, 0, "")
			return
		case "Int64Value":
			fs.Int64(name, 0, "")
			return
		case "UInt64Value":
			fs.Uint64(name, 0, "")
			return
		case "Int32Value":
			fs.Int32(name, 0, "")
			return
		case "UInt32Value":
			fs.Uint32(name, 0, "")
			return
		case "BoolValue":
			fs.Bool(name, false, "")
			return
		case "StringValue":
			fs.String(name, "", "")
			return
		case "BytesValue":
			fs.String(name, "", "(hex)")
			return
		}

	case "go.thethings.network/lorawan-stack/v3/pkg/ttnpb":
		switch typeName := t.Name(); typeName {
		case
			"ADRAckDelayExponentValue",
			"ADRAckLimitExponentValue",
			"AggregatedDutyCycleValue",
			"DataRateIndexValue",
			"PingSlotPeriodValue",
			"RxDelayValue":
			enumType := unwrapLoRaWANEnumType(typeName)
			values := make([]string, 0, len(proto.EnumValueMap(enumType)))
			for value := range proto.EnumValueMap(enumType) {
				values = append(values, value)
			}
			sort.Strings(values)
			fs.String(name, "", strings.Join(values, "|"))
			return

		case "Picture":
			// Not supported
			return
		}
		if t.Kind() == reflect.Int32 {
			if values := enumValues(t); values != nil {
				fs.String(name, "", strings.Join(values, "|"))
				return
			}
		}
	}

	switch t.Kind() {
	case reflect.Bool:
		fs.Bool(name, false, "")
		return
	case reflect.String:
		fs.String(name, "", "")
		return
	case reflect.Int32:
		fs.Int32(name, 0, "")
		return
	case reflect.Int64:
		fs.Int64(name, 0, "")
		return
	case reflect.Uint32:
		fs.Uint32(name, 0, "")
		return
	case reflect.Uint64:
		fs.Uint64(name, 0, "")
		return
	case reflect.Float32:
		fs.Float32(name, 0, "")
		return
	case reflect.Float64:
		fs.Float64(name, 0, "")
		return
	case reflect.Slice:
		el := t.Elem()
		switch el.PkgPath() {
		case "go.thethings.network/lorawan-stack/v3/pkg/ttnpb":
			switch el.Name() {
			case "GatewayAntennaIdentifiers":
				fs.StringSlice(name, nil, "")
				return
			}

		case "go.thethings.network/lorawan-stack/v3/pkg/types":
			switch el.Name() {
			case "DevAddrPrefix":
				fs.StringSlice(name, nil, "")
				return
			}
		}

		switch el.Kind() {
		case reflect.Bool:
			fs.BoolSlice(name, nil, "")
			return
		case reflect.String:
			fs.StringSlice(name, nil, "")
			return
		case reflect.Int32:
			if values := enumValues(el); values != nil {
				fs.StringSlice(name, nil, strings.Join(values, "|"))
				return
			}
			fs.IntSlice(name, nil, "")
			return
		case reflect.Int64:
			fs.IntSlice(name, nil, "")
			return
		case reflect.Uint8:
			fs.String(name, "", "(hex)")
			return
		case reflect.Uint32, reflect.Uint64:
			fs.UintSlice(name, nil, "")
			return
		case reflect.Ptr:
			// Not supported
			return
		}
		panic(fmt.Sprintf("flags: %s slice not yet supported (%s)\n", el.Kind(), name))
	case reflect.Array:
		el := t.Elem()
		switch el.Kind() {
		case reflect.Uint8:
			fs.String(name, "", "(hex)")
			return
		}
		panic(fmt.Sprintf("flags: %s array not yet supported (%s)\n", el.Kind(), name))
	case reflect.Map:
		// Not supported
		return
	}
	if t.PkgPath() == "" {
		panic(fmt.Sprintf("flags: %s not yet supported (%s)\n", t.Kind(), name))
	}
	panic(fmt.Sprintf("flags: %s.%s not yet supported (%s)\n", t.PkgPath(), t.Name(), name))
}

func fieldMaskFlags(prefix []string, t reflect.Type, maskOnly bool) *pflag.FlagSet {
	flagSet := &pflag.FlagSet{}
	props := proto.GetProperties(t)
	for _, prop := range props.Prop {
		if prop.Tag == 0 {
			continue
		}
		field, ok := t.FieldByName(prop.Name)
		if !ok {
			continue
		}
		path := append(prefix, prop.OrigName)
		fieldType := field.Type
		if fieldType.Kind() == reflect.Ptr {
			fieldType = fieldType.Elem()
		}
		name := strings.Join(path, ".")
		if !isSelectableField(name) {
			continue
		}
		if !maskOnly && !isSettableField(name) {
			continue
		}
		if isStopType(t, maskOnly) {
			continue
		}
		addField(flagSet, name, fieldType, maskOnly)
		if fieldType.Kind() == reflect.Struct && !isAtomicType(fieldType, maskOnly) {
			flagSet.AddFlagSet(fieldMaskFlags(path, fieldType, maskOnly))
		}
	}
	return flagSet
}

func trimPrefix(path []string, prefix ...string) []string {
	var nextElement int
	for i, prefix := range prefix {
		if i >= len(path) || path[i] != prefix {
			break
		}
		nextElement = i + 1
	}
	return path[nextElement:]
}

var flagValueError = errors.DefineInvalidArgument("flag_value", "invalid flag value")

func SetFields(dst interface{}, flags *pflag.FlagSet, prefix ...string) error {
	var flagValueErrorAttributes []interface{}
	rv := reflect.Indirect(reflect.ValueOf(dst))
	flags.VisitAll(func(flag *pflag.Flag) {
		if flag.Deprecated != "" || !flag.Changed {
			return
		}
		flagName := toUnderscore.Replace(flag.Name)
		var v interface{}
		switch flag.Value.Type() {
		case "bool":
			v, _ = flags.GetBool(flagName)
		case "string":
			v, _ = flags.GetString(flagName)
		case "int32":
			v, _ = flags.GetInt32(flagName)
		case "int64":
			v, _ = flags.GetInt64(flagName)
		case "uint32":
			v, _ = flags.GetUint32(flagName)
		case "uint64":
			v, _ = flags.GetUint64(flagName)
		case "float32":
			v, _ = flags.GetFloat32(flagName)
		case "float64":
			v, _ = flags.GetFloat64(flagName)
		case "stringSlice":
			v, _ = flags.GetStringSlice(flagName)
		case "intSlice":
			v, _ = flags.GetIntSlice(flagName)
		case "uintSlice":
			v, _ = flags.GetUintSlice(flagName)
		case "duration":
			v, _ = flags.GetDuration(flagName)
		}
		if v == nil {
			flagValueErrorAttributes = append(flagValueErrorAttributes,
				flag.Name, fmt.Errorf("can't set field to %s (%v)", flag.Value, flag.Value.Type()),
			)
		}
		if err := setField(rv, trimPrefix(strings.Split(flagName, "."), prefix...), reflect.ValueOf(v)); err != nil {
			flagValueErrorAttributes = append(flagValueErrorAttributes,
				flag.Name, err.Error(),
			)
		}
	})
	if len(flagValueErrorAttributes) > 0 {
		return flagValueError.WithAttributes(flagValueErrorAttributes...)
	}
	return nil
}

var (
	textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
)

func setField(rv reflect.Value, path []string, v reflect.Value) error {
	rt := rv.Type()
	vt := v.Type()
	props := proto.GetProperties(rt)
	for _, prop := range props.Prop {
		if prop.OrigName == path[0] {
			field := rv.FieldByName(prop.Name)
			if field.Type().Kind() == reflect.Ptr {
				if field.IsNil() {
					field.Set(reflect.New(field.Type().Elem()))
				}
				field = field.Elem()
			}
			ft := field.Type()
			if len(path) == 1 {
				switch {
				case ft.AssignableTo(vt):
					field.Set(v)
				case ft.Kind() == reflect.Int32 && vt.Kind() == reflect.String:
					if reflect.PtrTo(ft).Implements(textUnmarshalerType) {
						err := field.Addr().Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(v.String()))
						if err != nil {
							return err
						}
					} else {
						return fmt.Errorf(`%s does not implement encoding.TextUnmarshaler`, ft.Name())
					}
				case ft.PkgPath() == "time":
					switch {
					case ft.Name() == "Time" && vt.Kind() == reflect.String:
						var t time.Time
						var err error
						if v.String() != "" {
							t, err = time.Parse(time.RFC3339Nano, v.String())
							if err != nil {
								return err
							}
						}
						field.Set(reflect.ValueOf(t))
					case ft.Name() == "Duration" && vt.Kind() == reflect.String:
						d, err := time.ParseDuration(v.String())
						if err != nil {
							return err
						}
						field.Set(reflect.ValueOf(d))
					}
				case ft.PkgPath() == "github.com/gogo/protobuf/types":
					switch ft.Name() {
					case "DoubleValue":
						field.Set(reflect.ValueOf(types.DoubleValue{Value: v.Float()}))
					case "FloatValue":
						field.Set(reflect.ValueOf(types.FloatValue{Value: float32(v.Float())}))
					case "Int64Value":
						field.Set(reflect.ValueOf(types.Int64Value{Value: v.Int()}))
					case "UInt64Value":
						field.Set(reflect.ValueOf(types.UInt64Value{Value: v.Uint()}))
					case "Int32Value":
						field.Set(reflect.ValueOf(types.Int32Value{Value: int32(v.Int())}))
					case "UInt32Value":
						field.Set(reflect.ValueOf(types.UInt32Value{Value: uint32(v.Uint())}))
					case "BoolValue":
						field.Set(reflect.ValueOf(types.BoolValue{Value: v.Bool()}))
					case "StringValue":
						field.Set(reflect.ValueOf(types.StringValue{Value: v.String()}))
					case "BytesValue":
						s := strings.TrimPrefix(v.String(), "0x")
						buf, err := hex.DecodeString(s)
						if err != nil {
							return err
						}
						field.Set(reflect.ValueOf(types.BytesValue{Value: buf}))
					}
				case ft.PkgPath() == "go.thethings.network/lorawan-stack/v3/pkg/ttnpb":
					switch typeName := ft.Name(); typeName {
					case "DataRateIndexValue":
						if enumValue, ok := proto.EnumValueMap(unwrapLoRaWANEnumType(typeName))[v.String()]; ok {
							field.Set(reflect.ValueOf(ttnpb.DataRateIndexValue{Value: ttnpb.DataRateIndex(enumValue)}))
							break
						}
						var enum ttnpb.DataRateIndex
						if err := enum.UnmarshalText([]byte(v.String())); err != nil {
							field.Set(reflect.ValueOf(ttnpb.DataRateIndexValue{Value: enum}))
							break
						}
						return fmt.Errorf(`invalid value "%s" for %s`, v.String(), typeName)
					case "PingSlotPeriodValue":
						if enumValue, ok := proto.EnumValueMap(unwrapLoRaWANEnumType(typeName))[v.String()]; ok {
							field.Set(reflect.ValueOf(ttnpb.PingSlotPeriodValue{Value: ttnpb.PingSlotPeriod(enumValue)}))
							break
						}
						var enum ttnpb.PingSlotPeriod
						if err := enum.UnmarshalText([]byte(v.String())); err != nil {
							field.Set(reflect.ValueOf(ttnpb.PingSlotPeriodValue{Value: enum}))
							break
						}
						return fmt.Errorf(`invalid value "%s" for %s`, v.String(), typeName)
					case "AggregatedDutyCycleValue":
						if enumValue, ok := proto.EnumValueMap(unwrapLoRaWANEnumType(typeName))[v.String()]; ok {
							field.Set(reflect.ValueOf(ttnpb.AggregatedDutyCycleValue{Value: ttnpb.AggregatedDutyCycle(enumValue)}))
							break
						}
						var enum ttnpb.AggregatedDutyCycle
						if err := enum.UnmarshalText([]byte(v.String())); err != nil {
							field.Set(reflect.ValueOf(ttnpb.AggregatedDutyCycleValue{Value: enum}))
							break
						}
						return fmt.Errorf(`invalid value "%s" for %s`, v.String(), typeName)
					case "RxDelayValue":
						if enumValue, ok := proto.EnumValueMap(unwrapLoRaWANEnumType(typeName))[v.String()]; ok {
							field.Set(reflect.ValueOf(ttnpb.RxDelayValue{Value: ttnpb.RxDelay(enumValue)}))
							break
						}
						var enum ttnpb.RxDelay
						if err := enum.UnmarshalText([]byte(v.String())); err != nil {
							field.Set(reflect.ValueOf(ttnpb.RxDelayValue{Value: enum}))
							break
						}
						return fmt.Errorf(`invalid value "%s" for %s`, v.String(), typeName)
					case "ADRAckDelayExponentValue":
						if enumValue, ok := proto.EnumValueMap(unwrapLoRaWANEnumType(typeName))[v.String()]; ok {
							field.Set(reflect.ValueOf(ttnpb.ADRAckDelayExponentValue{Value: ttnpb.ADRAckDelayExponent(enumValue)}))
							break
						}
						var enum ttnpb.ADRAckDelayExponent
						if err := enum.UnmarshalText([]byte(v.String())); err != nil {
							field.Set(reflect.ValueOf(ttnpb.ADRAckDelayExponentValue{Value: enum}))
							break
						}
						return fmt.Errorf(`invalid value "%s" for %s`, v.String(), typeName)
					case "ADRAckLimitExponentValue":
						if enumValue, ok := proto.EnumValueMap(unwrapLoRaWANEnumType(typeName))[v.String()]; ok {
							field.Set(reflect.ValueOf(ttnpb.ADRAckLimitExponentValue{Value: ttnpb.ADRAckLimitExponent(enumValue)}))
							break
						}
						var enum ttnpb.ADRAckLimitExponent
						if err := enum.UnmarshalText([]byte(v.String())); err != nil {
							field.Set(reflect.ValueOf(ttnpb.ADRAckLimitExponentValue{Value: enum}))
							break
						}
						return fmt.Errorf(`invalid value "%s" for %s`, v.String(), typeName)
					}
				case ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && vt.Kind() == reflect.String:
					s := strings.TrimPrefix(v.String(), "0x")
					buf, err := hex.DecodeString(s)
					if err != nil {
						return err
					}
					field.Set(reflect.ValueOf(buf))
				case ft.Kind() == reflect.Array && ft.Elem().Kind() == reflect.Uint8 && vt.Kind() == reflect.String:
					s := strings.TrimPrefix(v.String(), "0x")
					buf, err := hex.DecodeString(s)
					if err != nil {
						return err
					}
					if len(buf) > 0 {
						if len(buf) != ft.Len() {
							return fmt.Errorf(`bytes of "%s" do not fit in [%d]byte`, v.String(), ft.Len())
						}
						for i := 0; i < ft.Len(); i++ {
							field.Index(i).Set(reflect.ValueOf(buf[i]))
						}
					} else {
						field.Set(reflect.Zero(ft))
					}
				case ft.Kind() == reflect.Slice && vt.Kind() == reflect.Slice:
					slice := reflect.MakeSlice(ft, v.Len(), v.Len())
					switch {
					case vt.Elem().ConvertibleTo(ft.Elem()):
						for i := 0; i < v.Len(); i++ {
							slice.Index(i).Set(v.Index(i).Convert(ft.Elem()))
						}
					case ft.Elem().PkgPath() == "go.thethings.network/lorawan-stack/v3/pkg/ttnpb" &&
						ft.Elem().Name() == "GatewayAntennaIdentifiers" && vt.Elem().Kind() == reflect.String:
						for i := 0; i < v.Len(); i++ {
							slice.Index(i).Set(reflect.ValueOf(ttnpb.GatewayAntennaIdentifiers{
								GatewayIdentifiers: ttnpb.GatewayIdentifiers{
									GatewayID: v.Index(i).String(),
								},
							}))
						}
					case ft.Elem().Kind() == reflect.Int32 && vt.Elem().Kind() == reflect.String:
						if reflect.PtrTo(ft.Elem()).Implements(textUnmarshalerType) {
							for i := 0; i < v.Len(); i++ {
								err := slice.Index(i).Addr().Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(v.Index(i).String()))
								if err != nil {
									return err
								}
							}
						} else {
							return fmt.Errorf(`%s does not implement encoding.TextUnmarshaler`, ft.Elem().Name())
						}
					default:
						return fmt.Errorf("%v is not convertible to %v", ft, vt)
					}
					field.Set(slice)
				default:
					return fmt.Errorf("%v is not assignable to %v", ft, vt)
				}
				return nil
			}
			return setField(field, path[1:], v)
		}
	}
	return fmt.Errorf("unknown field")
}

// SelectAllFlagSet returns a flagset with the --all flag
func SelectAllFlagSet(what string) *pflag.FlagSet {
	flagSet := &pflag.FlagSet{}
	flagSet.Bool("all", false, fmt.Sprintf("select all %s fields", what))
	return flagSet
}

// UnsetFlagSet returns a flagset with the --unset flag
func UnsetFlagSet() *pflag.FlagSet {
	flagSet := &pflag.FlagSet{}
	flagSet.StringSlice("unset", []string{}, "list of fields to unset")
	return flagSet
}

extension: go


text:
@misc{cudaguide,
    author    = "NVIDIA",
    title     = "CUDA C Programming Guide",
    year      = 2013
}

@article{liu2002discretization,
  title={Discretization: An enabling technique},
  author={Liu, Huan and Hussain, Farhad and Tan, Chew Lim and Dash, Manoranjan},
  journal={Data mining and knowledge discovery},
  volume={6},
  number={4},
  pages={393--423},
  year={2002},
  publisher={Springer}
}

@article{ramirez2016data,
  title={Data discretization: taxonomy and big data challenge},
  author={Ram{\'\i}rez-Gallego, Sergio and Garc{\'\i}a, Salvador and Mouri{\~n}o-Tal{\'\i}n, H{\'e}ctor and Mart{\'\i}nez-Rego, David and Bol{\'o}n-Canedo, Ver{\'o}nica and Alonso-Betanzos, Amparo and Ben{\'\i}tez, Jos{\'e} Manuel and Herrera, Francisco},
  journal={Wiley Interdisciplinary Reviews: Data Mining and Knowledge Discovery},
  volume={6},
  number={1},
  pages={5--21},
  year={2016},
  publisher={Wiley Online Library}
}

@inproceedings{fung2002mediated,
	title={Mediated reality using computer graphics hardware for computer vision},
	author={Fung, James and Tang, Felix and Mann, Steve},
	booktitle={Wearable Computers, 2002.(ISWC 2002). Proceedings. Sixth International Symposium on},
	pages={83--89},
	year={2002},
	organization={IEEE}
}

@inproceedings{icke2011multi,
	title={Multi-objective genetic programming for visual analytics},
	author={Icke, Ilknur and Rosenberg, Andrew},
	booktitle={European Conference on Genetic Programming},
	pages={322--334},
	year={2011},
	organization={Springer}
}

@article{guha2005data,
	title={Data visualization and mining using the gpu},
	author={Guha, Sudipto and Krisnan, S and Venkatasubramanian, Suresh},
	journal={Tutorial at ACM SIGKDD},
	volume={5},
	year={2005}
}
@inproceedings{larsen2001fast,
	title={Fast matrix multiplies using graphics hardware},
	author={Larsen, E Scott and McAllister, David},
	booktitle={Proceedings of the 2001 ACM/IEEE conference on Supercomputing},
	pages={55--55},
	year={2001},
	organization={ACM}
}

@article{hall2003cache,
	title={Cache and bandwidth aware matrix multiplication on the GPU},
	author={Hall, Jesse D and Carr, Nathan A and Hart, John C},
	year={2003},
	publisher={Citeseer}
}

@inproceedings{bolz2003sparse,
	title={Sparse matrix solvers on the GPU: conjugate gradients and multigrid},
	author={Bolz, Jeff and Farmer, Ian and Grinspun, Eitan and Schr{\"o}oder, Peter},
	booktitle={ACM Transactions on Graphics (TOG)},
	volume={22},
	number={3},
	pages={917--924},
	year={2003},
	organization={ACM}
}

@inproceedings{moreland2003fft,
	title={The FFT on a GPU},
	author={Moreland, Kenneth and Angel, Edward},
	booktitle={Proceedings of the ACM SIGGRAPH/EUROGRAPHICS conference on Graphics hardware},
	pages={112--119},
	year={2003},
	organization={Eurographics Association}
}

@inproceedings{von2004fourier,
	title={Fourier volume rendering on the GPU using a split-stream-FFT},
	author={von Rymon-Lipinski, Thomas Jansen Bartosz and Keeve, Nils Hanssen Erwin},
	booktitle={Vision, Modeling, and Visualization},
	pages={395},
	year={2004}
}

@inproceedings{hopf1999hardware,
	title={Hardware based wavelet transformations},
	author={Hopf, Matthias and Ertl, Thomas},
	booktitle={Vision, Modeling, and Visualization},
	volume={99},
	pages={317--328},
	year={1999}
}

@article{tenllado2008parallel,
	title={Parallel implementation of the 2D discrete wavelet transform on graphics processing units: filter bank versus lifting},
	author={Tenllado, Christian and Setoain, Javier and Prieto, Manuel and Pi{\~n}uel, Luis and Tirado, Francisco},
	journal={IEEE Transactions on Parallel and Distributed Systems},
	volume={19},
	number={3},
	pages={299--310},
	year={2008},
	publisher={IEEE}
}

@inproceedings{fogal2010large,
	title={Large data visualization on distributed memory multi-GPU clusters},
	author={Fogal, Thomas and Childs, Hank and Shankar, Siddharth and Kr{\"u}ger, Jens and Bergeron, R Daniel and Hatcher, Philip},
	booktitle={Proceedings of the Conference on High Performance Graphics},
	pages={57--66},
	year={2010},
	organization={Eurographics Association}
}
@inproceedings{song2015real,
  title={A real-time interactive data mining and visualization system using parallel computing},
  author={Song, Wei and Wu, Dong and Wong, Raymond and Fong, Simon and Cho, Kyungeun},
  booktitle={Digital Information Management (ICDIM), 2015 Tenth International Conference on},
  pages={10--13},
  year={2015},
  organization={IEEE}
}

@article{dzemyda2013multidimensional,
  title={Multidimensional data visualization},
  author={Dzemyda, Gintautas and Kurasova, Olga and Zilinskas, J},
  journal={Methods and applications series: Springer optimization and its applications},
  volume={75},
  pages={122},
  year={2013},
  publisher={Springer}
}

@inproceedings{fatahalian2004understanding,
  title={Understanding the efficiency of GPU algorithms for matrix-matrix multiplication},
  author={Fatahalian, Kayvon and Sugerman, Jeremy and Hanrahan, Pat},
  booktitle={Proceedings of the ACM SIGGRAPH/EUROGRAPHICS conference on Graphics hardware},
  pages={133--137},
  year={2004},
  organization={ACM}
}

@article{rech2013efficient,
  title={An efficient and experimentally tuned software-based hardening strategy for matrix multiplication on GPUs},
  author={Rech, P and Aguiar, C and Frost, C and Carro, L},
  journal={IEEE Transactions on Nuclear Science},
  volume={60},
  number={4},
  pages={2797--2804},
  year={2013},
  publisher={IEEE}
}

@article{dalton2015optimizing,
  title={Optimizing sparse matrix—matrix multiplication for the gpu},
  author={Dalton, Steven and Olson, Luke and Bell, Nathan},
  journal={ACM Transactions on Mathematical Software (TOMS)},
  volume={41},
  number={4},
  pages={25},
  year={2015},
  publisher={ACM}
}

@inproceedings{liu2013immens,
  title={imMens: Real-time Visual Querying of Big Data},
  author={Liu, Zhicheng and Jiang, Biye and Heer, Jeffrey},
  booktitle={Computer Graphics Forum},
  volume={32},
  number={3pt4},
  pages={421--430},
  year={2013},
  organization={Wiley Online Library}
}

@article{garcia2005gpu,
  title={GPU-based 3D wavelet reconstruction with tileboarding},
  author={Garcia, Antonio and Shen, Han-Wei},
  journal={The Visual Computer},
  volume={21},
  number={8-10},
  pages={755--763},
  year={2005},
  publisher={Springer}
}

@article{franco20122d,
  title={The 2D wavelet transform on emerging architectures: GPUs and multicores},
  author={Franco, Joaqu{\'\i}n and Bernab{\'e}, Gregorio and Fern{\'a}ndez, Juan and Ujald{\'o}n, Manuel},
  journal={Journal of Real-Time Image Processing},
  volume={7},
  number={3},
  pages={145--152},
  year={2012},
  publisher={Springer}
}


text:
@article{RN8186,
   author = {Story, Dee Ann},
   title = {{1968-1970 Archeological Investigations at the George C. Davis Site, Cherokee County, Texas}},
   journal = {Bulletin of the Texas Archeological Society},
   volume = {68},
   pages = {1-113},
   year = {1997},
   type = {Journal Article}
}

@article{RN8174,
   author = {Webb, Clarence H. and McKinney, Ralph R.},
   title = {{Mounds Plantation (16CD12), Caddo Parish, Louisiana}},
   journal = {Louisiana Archaeology},
   volume = {2},
   pages = {39-128},
   year = {1975},
   type = {Journal Article}
}

@article{RN8176,
   author = {Webb, Clarence H. and Dodd Jr., Monroe},
   title = {{Further Excavations of the Gahagan Mound: Connections with a Florida Culture}},
   journal = {Bulletin of the Texas Archeological and Paleontological Society},
   volume = {11},
   pages = {92-126},
   year = {1939},
   type = {Journal Article}
}

@article{RN8071,
   author = {Selden Jr., Robert Z.},
   title = {A Preliminary Study of Smithport Plain Bottle Morphology in the Southern Caddo Area},
   journal = {Bulletin of the Texas Archeological Society},
   volume = {89},
   pages = {63-89},
   url = {https://scholarworks.sfasu.edu/crhr/283/},
   year = {2018},
   type = {Journal Article}
}

@article{RN7925,
   author = {Selden Jr., Robert Z.},
   title = {Ceramic Morphological Organisation in the Southern Caddo Area: Quiddity of Shape for Hickory Engraved Bottles},
   journal = {Journal of Archaeological Science: Reports},
   volume = {21},
   pages = {884-896},
   ISSN = {2352409X},
   DOI = {10.1016/j.jasrep.2018.08.045},
   url = {https://www.sciencedirect.com/science/article/abs/pii/S2352409X18302700},
   year = {2018},
   type = {Journal Article}
}

@article{RN8361,
   author = {Selden Jr., Robert Z.},
   title = {Ceramic Morphological Organisation in the Southern Caddo Area: The Clarence H. Webb Collections},
   journal = {Journal of Cultural Heritage},
   volume = {35},
   pages = {41-55},
   DOI = {10.1016/j.culher.2018.07.002},
   url = {https://www.sciencedirect.com/science/article/abs/pii/S1296207418301912?via%3Dihub},
   year = {2019},
   type = {Journal Article}
}

@inbook{RN8967,
   author = {Selden Jr., Robert Z.},
   title = {Louisiana Limitrophe: An Iterative Morphological Exegesis of Caddo Bottle and Biface Production},
   booktitle = {Ancestral Caddo Ceramic Traditions},
   editor = {McKinnon, Duncan P. and Girard, Jeffrey S. and Perttula, Timothy K.},
   publisher = {LSU Press},
   address = {Baton Rouge},
   pages = {258-276},
   url = {https://osf.io/preprints/socarxiv/rpnd5/},
   year = {2021},
   type = {Book Section}
}

@article{RN8154,
   author = {Selden Jr., Robert Z. and Dockall, John E. and Shafer, Harry J.},
   title = {Lithic Morphological Organisation: Gahagan Bifaces from the Southern Caddo Area},
   journal = {Digital Applications in Archaeology and Cultural Heritage},
   volume = {10},
   pages = {e00080},
   ISSN = {22120548},
   DOI = {10.1016/j.daach.2018.e00080},
   url = {https://www.sciencedirect.com/science/article/abs/pii/S2212054818300183},
   year = {2018},
   type = {Journal Article}
}

@article{RN8318,
   author = {Selden Jr., Robert Z. and Dockall, John E. and Dubied, Morgane},
   title = {A quantitative assessment of intraspecific morphological variation in Gahagan bifaces from the southern Caddo area and central Texas},
   journal = {Southeastern Archaeology},
   volume = {39},
   number = {2},
   pages = {125-145},
   ISSN = {0734-578X
2168-4723},
   DOI = {10.1080/0734578x.2020.1744416},
   url = {https://www.tandfonline.com/doi/full/10.1080/0734578X.2020.1744416},
   year = {2020},
   type = {Journal Article}
}

@article{RN7107,
   author = {Moore, Clarence B.},
   title = {Some Aboriginal Sites on Red River},
   journal = {Journal of the Academy of Natural Sciences of Philadelphia},
   volume = {14},
   number = {4},
   pages = {526-636},
   year = {1912},
   type = {Journal Article}
}

@article{RN10759,
   author = {Tunnell, Curtis},
   title = {In Their Own Words: Stories from Some Pioneer Texas Archeologists},
   journal = {Bulletin of the Texas Archeological Society},
   volume = {71},
   pages = {1-146},
   year = {2000},
   type = {Journal Article}
}

@article{RN9364,
   author = {Selden Jr, Robert Z. and Dockall, John E. and Bousman, C. Britt and Perttula, Timothy K.},
   title = {Shape as a function of time + raw material + burial context? An exploratory analysis of Perdiz arrow points from the ancestral Caddo area of the American Southeast},
   journal = {Journal of Archaeological Science: Reports},
   volume = {37},
   pages = {102916},
   ISSN = {2352409X},
   DOI = {10.1016/j.jasrep.2021.102916},
   url = {https://www.sciencedirect.com/science/article/pii/S2352409X21001280},
   year = {2021},
   type = {Journal Article}
}

@inbook{RN8312,
   author = {Gray, Charles T. and Marwick, Ben},
   title = {Truth, Proof, and Reproducibility: There's No Counter-Attack for the Codeless},
   booktitle = {Statistics and Data Science},
   series = {Communications in Computer and Information Science},
   chapter = {Chapter 8},
   pages = {111-129},
   ISBN = {978-981-15-1959-8
978-981-15-1960-4},
   DOI = {10.1007/978-981-15-1960-4_8},
   year = {2019},
   type = {Book Section}
}

@article{RN8313,
   author = {Peng, Roger D.},
   title = {Reproducible Research in Computational Science},
   journal = {Science},
   volume = {334},
   number = {6060},
   pages = {1226-7},
   ISSN = {1095-9203 (Electronic)
0036-8075 (Linking)},
   DOI = {10.1126/science.1213847},
   url = {https://www.ncbi.nlm.nih.gov/pubmed/22144613},
   year = {2011},
   type = {Journal Article}
}

@book{RN8299,
   author = {Gandrud, Christopher},
   title = {Reproducible Research with R and RStudio},
   publisher = {CRC Press},
   address = {London},
   series = {The R Series},
   year = {2014},
   type = {Book}
}

@article{RN8207,
   author = {Marwick, Ben},
   title = {Computational Reproducibility in Archaeological Research: Basic Principles and a Case Study of Their Implementation},
   journal = {Journal of Archaeological Method and Theory},
   volume = {24},
   number = {2},
   pages = {424-450},
   ISSN = {1072-5369
1573-7764},
   DOI = {10.1007/s10816-015-9272-9},
   year = {2016},
   type = {Journal Article}
}

@article{RN8965,
   author = {Ivanovaite, Livija and Serwatka, Kamil and Hoggard, Christian Steven and Sauer, Florian and Riede, Felix},
   title = {All these Fantastic Cultures? Research History and Regionalization in the Late Palaeolithic Tanged Point Cultures of Eastern Europe},
   journal = {European Journal of Archaeology},
   volume = {23},
   number = {2},
   pages = {162-185},
   ISSN = {1461-9571
1741-2722},
   DOI = {10.1017/eaa.2019.59},
   year = {2019},
   type = {Journal Article}
}

@article{RN10760,
   author = {Marwick, Ben and Wang, Li-Ying and Robinson, Ryan and Loiselle, Hope},
   title = {How to Use Replication Assignments for Teaching Integrity in Empirical Archaeology},
   journal = {Advances in Archaeological Practice},
   volume = {8},
   number = {1},
   pages = {78-86},
   ISSN = {2326-3768},
   DOI = {10.1017/aap.2019.38},
   year = {2019},
   type = {Journal Article}
}

@article{RN10761,
   author = {Peels, R. and Bouter, L.},
   title = {Humanities need a replication drive too},
   journal = {Nature},
   volume = {558},
   number = {7710},
   pages = {372},
   ISSN = {1476-4687 (Electronic)
0028-0836 (Linking)},
   DOI = {10.1038/d41586-018-05454-w},
   url = {https://www.ncbi.nlm.nih.gov/pubmed/29921855},
   year = {2018},
   type = {Journal Article}
}

@book{RN8233,
   author = {O'Brien, Michael J. and Lyman, R. Lee},
   title = {Seriation, Stratigraphy, and Index Fossils: The Backbone of Archaeological Dating},
   publisher = {Kluwer Academic/Plenum Publishers},
   address = {New York},
   year = {1999},
   type = {Book}
}

@article{RN5764,
   author = {Suhm, Dee Ann and Krieger, Alex D. and Jelks, Edward B.},
   title = {An Introductory Handbook of Texas Archeology},
   journal = {Bulletin of the Texas Archeological Society},
   volume = {25},
   pages = {1-562},
   year = {1954},
   type = {Journal Article}
}

@article{RN6840,
   author = {Suhm, Dee Ann},
   title = {Handbook of Texas Archeology: Type Descriptions. A Cumulative Compendium of Type Descriptions},
   journal = {The Texas Memorial Museum Bulletin},
   volume = {4},
   pages = {1-297},
   year = {1962},
   type = {Journal Article}
}

repository: aksel-blaise/quercus

repo_name: aksel-blaise/quercus

branch_name: refs/heads/main


text:
@book{SaleemSiddiqui_2021,
 author = {Siddiqui, Saleem},
 isbn = {9781098106478},
 note = {Foreword by Konstantin Läufer},
 publisher = {O'Reilly Media, Inc.},
 title = {Learning Test-Driven Development},
 url = {https://learning.oreilly.com/library/view/learning-test-driven-development/9781098106461/foreword01.html},
 year = {2021}
}


text:
package main

import (
	"testing"

	"github.com/stretchr/testify/assert"

	"github.com/256dpi/fire"
	"github.com/256dpi/fire/coal"
)

func TestEnsureIndexes(t *testing.T) {
	withTester(t, func(t *testing.T, tester *fire.Tester) {
		for _, model := range models.All() {
			tester.Drop(model)
		}
		assert.NoError(t, coal.EnsureIndexes(tester.Store, models.All()...))
		assert.NoError(t, coal.EnsureIndexes(tester.Store, models.All()...))
	})
}

func TestItem(_ *testing.T) {
	coal.Require(&Item{}, "fire-soft-delete")

	var _ coal.Model = &Item{}
}

gha_license_id: MIT

gha_language: Go


text:
@article{mukherjee_cellphones_2011,
	title = {Do Cellphones Cause Brain Cancer?},
	issn = {0362-4331},
	url = {http://www.nytimes.com/2011/04/17/magazine/mag-17cellphones-t.html},
	abstract = {Description: An excellent overview of the limitations of Epidemiological research, illustrated by the perplexing findings about the link (or lack thereof) between cell phone use and brain cancer. My only complaint is that they did not address how difficult it is to decide when to close the door on further research. How many negative studies can you tolerate before you say, "Enough! Let's move on to something else."},
	journaltitle = {The New York Times},
	author = {Mukherjee, Siddhartha},
	urldate = {2011-05-04},
	date = {2011-04-13},
	tags = {Brain, Cancer, Cellular Telephones, Medicine and Health, Radiation}
}

repository: pmean/build-website

repo_name: pmean/build-website


text:
SECTION = "devel/chicken"
DESCRIPTION = "QobiScheme-compatible define-structure"
LICENSE = "LGPLv2+"
LIC_FILES_CHKSUM = "file://define-structure.meta;md5=4ab4f977773cd6c459a2d5c4d5916cc8"
DEPENDS_append_class-cross = " chicken-egg-setup-helper-cross chicken-egg-miscmacros-cross chicken-egg-check-errors-cross chicken-egg-condition-utils-cross chicken-egg-nondeterminism-cross"
DEPENDS_append_class-crosssdk = " chicken-egg-setup-helper-crosssdk chicken-egg-miscmacros-crosssdk chicken-egg-check-errors-crosssdk chicken-egg-condition-utils-crosssdk chicken-egg-nondeterminism-crosssdk"
DEPENDS_append_class-nativesdk = " nativesdk-chicken-egg-setup-helper nativesdk-chicken-egg-miscmacros nativesdk-chicken-egg-check-errors nativesdk-chicken-egg-condition-utils nativesdk-chicken-egg-nondeterminism chicken-egg-setup-helper-crosssdk chicken-egg-miscmacros-crosssdk chicken-egg-check-errors-crosssdk chicken-egg-condition-utils-crosssdk chicken-egg-nondeterminism-crosssdk"
DEPENDS = " chicken-egg-setup-helper chicken-egg-miscmacros chicken-egg-check-errors chicken-egg-condition-utils chicken-egg-nondeterminism chicken-egg-setup-helper-cross chicken-egg-miscmacros-cross chicken-egg-check-errors-cross chicken-egg-condition-utils-cross chicken-egg-nondeterminism-cross"
RDEPENDS_${PN} = " chicken-egg-setup-helper chicken-egg-miscmacros chicken-egg-check-errors chicken-egg-condition-utils chicken-egg-nondeterminism"

SRC_URI = "http://code.call-cc.org/egg-tarballs/4/define-structure/define-structure-${PV}.tar.gz"

SRC_URI[md5sum] = "642578d5c968cb159e8bb8c1667826a3"
SRC_URI[sha256sum] = "35b55d51be65db6731dfb92de6abc8cc0c6881c8ad99866e18a0d9988824d7d6"

S = "${WORKDIR}/define-structure-${PV}"

inherit chicken_install

BBCLASSEXTEND = "cross crosssdk nativesdk"

repository: OSSystems/meta-chicken

repo_name: OSSystems/meta-chicken


text:
DESCRIPTION = "A minimal version of the Mozilla web browser"
HOMEPAGE="http://www.mozilla.org/projects/minimo/"
SRC_URI = "cvs://anonymous@cvs-mirror.mozilla.org/cvsroot;module=mozilla \
           file://xptcstubs.patch;patch=1 \
	   file://no-xmb.patch;patch=1 \
	   file://host_ldflags_fix.patch;patch=1 \
	   file://minimo.png file://minimo.desktop"
S = "${WORKDIR}/mozilla"
MAINTAINER = "Phil Blundell <pb@handhelds.org>"
SECTION = "x11"
PRIORITY = "optional"
PV = "0.0cvs${CVSDATE}"
FILES_${PN} += "${libdir}/mozilla-minimo"
PR = "r8"
LICENSE = "MPL/LGPL/GPL"

inherit mozilla

EXTRA_OECONF += "--enable-application=suite"
export MOZ_CO_PROJECT="suite"

export MINIMO=1
export MOZ_OBJDIR="${WORKDIR}/build-${TARGET_SYS}"

include mozilla-cvs.inc

do_compile () {
	mozilla_do_compile
	cd $MOZ_OBJDIR/embedding/minimo
	oe_runmake
}

mozdir="${D}${libdir}/mozilla-minimo"

do_install () {
	cd ${S}/embedding/minimo/
	sh ./package.sh
	cd ${S}
	mkdir -p ${mozdir}
	cp -rL $MOZ_OBJDIR/dist/Embed/* ${mozdir}/
	rm -f ${mozdir}/TestGtkEmbed
	mkdir -p ${D}${datadir}/applications
	install -m 0644 ${WORKDIR}/minimo.desktop ${D}${datadir}/applications/minimo.desktop
	mkdir -p ${D}${datadir}/pixmaps
	install -m 0644 ${WORKDIR}/minimo.png ${D}${datadir}/pixmaps/minimo.png
	mkdir -p ${D}${bindir}
	echo "#!/bin/sh" > ${D}${bindir}/minimo
	cat >>${D}${bindir}/minimo << EOF
cd ${libdir}/mozilla-minimo
export LD_LIBRARY_PATH=${libdir}/mozilla-minimo
exec ./Minimo http://www.mozilla.org/projects/minimo/home.html
EOF
	chmod 755 ${D}${bindir}/minimo
}

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux


text:
set(CPP_FILES
  m2CoreIOActivator.cpp
  m2ImzMLImageIO.cpp
  m2ImzMLEngine.cpp
  m2OpenSlideIO.cpp
  m2FSMImageIO.cpp
)

extension: cmake


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

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

# Import target "rmf_workcell_msgs::rmf_workcell_msgs__rosidl_generator_c" for configuration "Release"
set_property(TARGET rmf_workcell_msgs::rmf_workcell_msgs__rosidl_generator_c APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(rmf_workcell_msgs::rmf_workcell_msgs__rosidl_generator_c PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/librmf_workcell_msgs__rosidl_generator_c.so"
  IMPORTED_SONAME_RELEASE "librmf_workcell_msgs__rosidl_generator_c.so"
  )

list(APPEND _IMPORT_CHECK_TARGETS rmf_workcell_msgs::rmf_workcell_msgs__rosidl_generator_c )
list(APPEND _IMPORT_CHECK_FILES_FOR_rmf_workcell_msgs::rmf_workcell_msgs__rosidl_generator_c "${_IMPORT_PREFIX}/lib/librmf_workcell_msgs__rosidl_generator_c.so" )

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


text:
@article{Tu2019,
 abstract = {Microgrids are seen as an effective way to achieve reliable, resilient, and efficient operation of the power distribution system. Core functions of the microgrid control system are defined by the IEEE standard 2030.7; however, the algorithms that realize these functions are not standardized, and are a topic of research. Furthermore, the corresponding controller hardware, operating system, and communication system to implement these functions vary significantly from one implementation to the next. In this paper, we introduce an open-source platform, Resilient Information Architecture Platform for the Smart Grid (RIAPS), ideally suited for implementing and deploying distributed microgrid control algorithms. RIAPS provides a design-time tool suite for development and deployment of distributed microgrid control algorithms. With support from a number of run-time platform services, developed algorithms can be easily implemented and deployed into real microgrids. To demonstrate the unique features of RIAPS, we propose and implement a distributed microgrid secondary control algorithm capable of synchronized and proportional compensation of voltage unbalance using distributed generators. Test results show the effectiveness of the proposed control and the salient features of the RIAPS platform.},
 author = {H. Tu and Y. Du and H. Yu and Abhishek Dubey and S. Lukic and G. Karsai},
 doi = {10.1109/TIE.2019.2952803},
 file = {:Tu2019-Resilient_Information_Architecture_Platform_for_the_Smart_Grid(RIAPS)_A_Novel_Open-Source_Platform_for_Microgrid_Control.pdf:PDF},
 issn = {1557-9948},
 journal = {IEEE Transactions on Industrial Electronics},
 keywords = {},
 oldkeywords = {smartgrid},
 pages = {1-1},
 project = {cps-middleware,cps-reliability,smart-energy},
 tag = {decentralization,power},
 title = {Resilient Information Architecture Platform for the Smart Grid (RIAPS): A Novel Open-Source Platform for Microgrid Control},
 year = {2019}
}


text:
@inproceedings{basu2011ppcfgaej,
 address = {Niigata, Japan},
 author = {Basu, Anirban and Vaidya, Jaideep and Kikuchi, Hiroaki and Dimitrakos, Theo},
 booktitle = {Proceedings of the Computer Security Symposium (CSS)},
 title = {Practical privacy preserving collaborative filtering on the Google App Engine},
 year = {2011}
}

gha_language: TeX


text:
DESCRIPTION = "Network Block Device"
HOMEPAGE = "http://nbd.sourceforge.net"
SECTION = "net"
LICENSE = "GPL-2.0-only"
LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263"

DEPENDS = "autoconf-archive bison-native glib-2.0 libnl"

SRC_URI = "${SOURCEFORGE_MIRROR}/${BPN}/${BPN}-${PV}.tar.xz"
SRC_URI[md5sum] = "a6d9e7bbc311a2ed07ef84a58b82b5dd"
SRC_URI[sha256sum] = "6877156d23a7b33f75eee89d2f5c2c91c542afc3cdcb636dea5a88539a58d10c"

inherit autotools pkgconfig

PACKAGES = "${PN}-client ${PN}-dbg ${PN}-doc ${PN}-server ${PN}-trdump ${PN}-trplay"

FILES:${PN}-client = "${sbindir}/${BPN}-client"
FILES:${PN}-server = "${bindir}/${BPN}-server"
FILES:${PN}-trdump = "${bindir}/${BPN}-trdump"
FILES:${PN}-trplay = "${bindir}/${BPN}-trplay"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded

gha_language: BitBake


text:
@inproceedings{meister+al.emnlp21a,
  title = {Revisiting the Uniform Information Density Hypothesis},
  venue = {EMNLP},
  year = {2021},
  slides = {https://docs.google.com/presentation/d/1e1cn2O7zN16GKVzlSj6EDw7jme61zuLGiFPZPXlO7hE/edit?usp=sharing},
  video = {https://www.youtube.com/watch?v=ZhNwqUn-qPc},
  code = {https://github.com/rycolab/revisiting-uid},
  arXiv = {https://arxiv.org/abs/2109.11635},
  author = {Meister, Clara and
	Pimentel, Tiago and
	Haller, Patrick and
	J{\"a}ger, Lena and
	Cotterell, Ryan and
	Levy, Roger},
  booktitle = {Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing},
  month = {November},
  publisher = {Association for Computational Linguistics},
  pages = {963--980},
  abstract = {The uniform information density (UID) hypothesis posits a preference among language users for utterances structured such that information is distributed uniformly across a signal. While its implications on language production have been well explored, the hypothesis potentially makes predictions about language comprehension and linguistic acceptability as well. Further, it is unclear how uniformity in a linguistic signal -- or lack thereof -- should be measured, and over which linguistic unit, e.g., the sentence or language level, this uniformity should hold. Here we investigate these facets of the UID hypothesis using reading time and acceptability data. While our reading time results are generally consistent with previous work, they are also consistent with a weakly super-linear effect of surprisal, which would be compatible with UID's predictions. For acceptability judgments, we find clearer evidence that non-uniformity in information density is predictive of lower acceptability. We then explore multiple operationalizations of UID, motivated by different interpretations of the original hypothesis, and analyze the scope over which the pressure towards uniformity is exerted. The explanatory power of a subset of the proposed operationalizations suggests that the strongest trend may be a regression towards a mean surprisal across the language, rather than the phrase, sentence, or document -- a finding that supports a typical interpretation of UID, namely that it is the byproduct of language users maximizing the use of a (hypothetical) communication channel.},
  url = {https://arxiv.org/abs/2109.11635},
}

repository: rycolab/website

repo_name: rycolab/website


text:
# existing upstream recipe does not have a native version
SUMMARY = "Recipe to embedded the Python PiP Package thrift"
HOMEPAGE ="https://pypi.org/project/thrift"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=2ba8bcf874551cc47b1c430e18ec4163"

inherit pypi setuptools3 native
PYPI_PACKAGE = "thrift"
SRC_URI[md5sum] = "c3bc8d9a910d2c9ce26f2ad1f7c96762"
SRC_URI[sha256sum] = "9af1c86bf73433afc6010ed376a6c6aca2b54099cc0d61895f640870a9ae7d89"

repository: wallinux/meta-codechecker

repo_name: wallinux/meta-codechecker


text:
@article{koubi2019climate,
  title={Climate change and conflict},
  author={Koubi, Vally},
  journal={Annual review of political science},
  volume={22},
  pages={343--360},
  year={2019},
  DOI={10.1146/annurev-polisci-050317-070830},
  publisher={Annual Reviews}
}

@article{mach2019climate,
  title={Climate as a risk factor for armed conflict},
  author={Mach, Katharine J and Kraan, Caroline M and Adger, W Neil and Buhaug, Halvard and Burke, Marshall and Fearon, James D and Field, Christopher B and Hendrix, Cullen S and Maystadt, Jean-Francois and O’Loughlin, John and others},
  journal={Nature},
  volume={571},
  number={7764},
  pages={193--197},
  year={2019},
  DOI={10.1038/s41586-019-1300-6},
  publisher={Nature Publishing Group}
}

@article{cederman2017predicting,
  title={Predicting armed conflict: Time to adjust our expectations?},
  author={Cederman, Lars-Erik and Weidmann, Nils B},
  journal={Science},
  volume={355},
  number={6324},
  pages={474--476},
  year={2017},
  DOI={10.1126/science.aal4483},
  publisher={American Association for the Advancement of Science}
}

@article{hegre2016forecasting,
  title={Forecasting civil conflict along the shared socioeconomic pathways},
  author={Hegre, H{\aa}vard and Buhaug, Halvard and Calvin, Katherine V and Nordkvelle, Jonas and Waldhoff, Stephanie T and Gilmore, Elisabeth},
  journal={Environmental Research Letters},
  volume={11},
  number={5},
  pages={054002},
  year={2016},
  DOI={10.1088/1748-9326/11/5/054002},
  publisher={IOP Publishing}
}

@article{hegre2017introduction,
  title = {Introduction: Forecasting in peace research},
  author = {Håvard Hegre and Nils W Metternich and Håvard Mokleiv Nygård and Julian Wucherpfennig},
  journal = {Journal of Peace Research},
  volume = {54},
  number = {2},
  pages={113-124},
  year={2017},
  DOI={10.1177/0022343317691330},
  publisher={SAGE Publications Sage UK: London, England},
}

@article{colaresi2017robot,
  title={Do the robot: Lessons from machine learning to improve conflict forecasting},
  author={Colaresi, Michael and Mahmood, Zuhaib},
  journal={Journal of Peace Research},
  volume={54},
  number={2},
  pages={193--214},
  year={2017},
  DOI={10.1177/0022343316682065},
  publisher={SAGE Publications Sage UK: London, England}
}

@article{witmer2017subnational,
  title={Subnational violent conflict forecasts for sub-Saharan Africa, 2015--65, using climate-sensitive models},
  author={Witmer, Frank DW and Linke, Andrew M and O’Loughlin, John and Gettelman, Andrew and Laing, Arlene},
  journal={Journal of Peace Research},
  volume={54},
  number={2},
  pages={175--192},
  year={2017},
  DOI={10.1177/0022343316682064},
  publisher={SAGE Publications Sage UK: London, England}
}

repository: JannisHoch/copro

repo_name: JannisHoch/copro

branch_name: refs/heads/dev

gha_language: Jupyter Notebook


text:
DESCRIPTION = "mergepont5200 bin"
HOMEPAGE = "http://www.avocent.com"
SECTION = "app"

#DEPENDS="openssl unixodbc tcl postgresql"
DEPENDS = "dsi5200_cvs"

S="${WORKDIR}/../mergepoint5200-1.0-r0/project_caesar"

#EXTRA_OEMAKE = "-f bldconf.lnx"
#
PARALLEL_MAKE=""

export CC="${HOST_PREFIX}gcc -isystem ${STAGING_INCDIR}"

#python do_unpack() {
#	bb.build.exec_func('base_do_unpack', d)
#	bb.build.exec_func('cvs_do_unpack', d)
#}

#cvs_do_unpack () {
#	if [ -z ${MERGEPOINT_TAG} ]; then
#		(cd ${S}/modules; ./caesarco.py  -r HEAD all;)
#	else
#		(cd ${S}/modules; ./caesarco.py  -r ${MERGEPOINT_TAG} all;)
#	fi
#}

#do_compile() {
#	[ -d bin ] || mkdir bin
#	for cmd in `ls ${CROSS_DIR}/bin/${HOST_PREFIX}*`; do
#		cmdalias=`echo $cmd | sed -r "s/.*${HOST_PREFIX}//g"`
#		alias $cmdalias=${HOST_PREFIX}$cmdalias
#		ln -sf $cmd bin/$cmdalias
#	done
#
#	rm -f bin/gcc bin/g++
#
#	echo -e "#!/bin/bash\n ${HOST_PREFIX}gcc -isystem ${STAGING_INCDIR}" '$@' > bin/gcc
#	echo -e "#!/bin/bash\n ${HOST_PREFIX}g++ -isystem ${STAGING_INCDIR}" '$@' > bin/g++
#
#	chmod +x bin/gcc bin/g++
#
#	export JAVA_HOME=/opt/j2sdk1.4.2_09
#	export ANT_HOME=/usr/local
#
#	export PATH="$JAVA_HOME/bin:${S}/bin:$PATH"
#
#	false
#   	(cd builds; ./go.py)
#}

do_install () {
	pushd ${S}/builds/Installation_embed
	#appname="caesar_app`date +%Y%m%d%H%M`.tgz"
     	#./build.sh && tar czf ${appname} linux-2.6-intel
     	#if [ -e ${appname} ]; then
	#	cp -f ${appname} ${DEPLOY_DIR_IMAGE}
	#fi

	# To make a upgrade bin file.
	export BINFILE=/opt/MP_3.0.0.2006101301.bin
	export GZFILE=data.tar.gz
	export TARFILE=data.tar
	export EPMFILE=caesar.list
	export INSTALLFILES=install.files
	export IGNOREFILES="./www/htdocs/htmls.tar ./etc/network/interfaces"
	export OUTPUTDIR=../source/common/output/server
	ezport OUTBIN=MergePoint5200_`date +%Y%m%d%H%M`.bin
	[ -e makebin.log ] && rm -f makebin.log
	[ -e install.files ] && rm -f install.files
	[ -e usr/share/zoneinfo ] && chmod u+x usr/share/zoneinfo
	unpackage -x ${BINFILE} -o ${GZFILE} --on on.sh --pre pre_upgrade.sh --post post_upgrade.sh
	chmod u+r ${GZFILE}
	gunzip ${GZFILE}
    	tar xf ${TARFILE}
    	if [ ! -d dsview/DSI5200/data ]; then
        	tar --delete -f ${TARFILE} ./dsview/DSI5200/etc
        	mv dsview/DSI5200/etc dsview/DSI5200/data
        	tar -uf ${TARFILE} ./dsview/DSI5200/data
    	fi
        # All file should to be installed.
    	grep "^f 0" ${EPMFILE} > $INSTALLFILES
    	sed -e 's|${SRCROOT}|/home/caesar/project_caesar/builds/source/common/output/server|' $INSTALLFILES \
    	| sed -e 's| ./| /home/caesar/project_caesar/builds/Installation_embed/|' \
    	| sed -e 's| ../| /home/caesar/project_caesar/builds/|' > tmp.list
    	mv tmp.list $INSTALLFILES

	# Prepare work, to make local files' mode same with dest.
	strip ./dsview/DSI5200/bin/aidpd
	strip ${OUTPUTDIR}/aidpd
	chmod +s ${OUTPUTDIR}/*.cgi
	chmod +s ${OUTPUTDIR}/clp

    	while read LINE
    	do
        	mod=`echo $LINE | cut -d " " -f2`
        	installpath=.`echo $LINE | cut -d " " -f5`
        	installdir=.`dirname $installpath`
        	srcpath=`echo $LINE | cut -d " " -f6`
        	rootdir=`echo $installpath | cut -c1-6`
        	if [ $rootdir = "./data" ]; then
            		continue
        	fi
        	echo $IGNOREFILES | grep $installpath
        	if [ 0 -eq $? ]; then
            		continue
        	fi
        	# new added file
        	if [ ! -f $installpath ]; then
            		mkdir -p $installdir
        	else
            		diff -q $installpath $srcpath
        	fi
        	cp -f $srcpath $installpath
        	tar -uf $TARFILE $installpath
    	done < $INSTALLFILES

	tar --delete -f ${TARFILE} ./var/www/htdocs
	cp ${OUTPUTWEB}/htmls.tar var/www/htdocs
	pushd var/www/htdocs
	tar xf htmls.tar
	popd

	gzip ${TARFILE}

	package -o ${OUTBIN} -t CAESARUPGRADEBIN --pre /home/caesar/appliance/upgrade/pre_upgrade.sh --on /home/caesar/appliance/upgrade/on.sh --post /home/caesar/appliance/upgrade/post_upgrade.sh CAESAR_V_1.0.0.0 -i ${GZFILE}
    	chmod a+r ${OUTBIN}

	popd
}


text:
@article{krupa_dna_2011,
 abstract = {The cellular reaction to the DNA-damaging agents may modulate individual's cancer susceptibility. This reaction is mainly determined by the efficacy of DNA repair, which in turn, may be influenced by the variability of DNA repair genes, expressed by their polymorphism. The hOGG1 gene encodes a glycosylase of base excision repair and RAD51 specifies a key protein in homologues recombination repair. Both proteins can be involved in the repair of DNA lesions, which are known to contribute to endometrial cancer. In the present work we determined the extent of basal DNA damage and the efficacy of removal of DNA damage induced by hydrogen peroxide and N-methyl-N'-nitro N-nitrosoguanidyne (MNNG) in peripheral blood lymphocytes of 30 endometrial cancer patients and 30 individuals without cancer. The results from DNA damage and repair study were correlated with the genotypes of two common polymorphisms of the hOGG1 and RAD51 genes: a G{\textgreater}C transversion at 1245 position of the hOGG1 gene producing a Ser → Cys substitution at the codon 326 (the Ser326Cys polymorphism) and a G{\textgreater}C substitution at 135 position of the RAD51 gene (the 135G{\textgreater}C polymorphism). DNA damage and repair were evaluated by alkaline single cell gel electrophoresis and genotypes were determined by restriction fragment length polymorphism PCR. We observed a strong association between endometrial cancer and the C/C genotype of the 135G{\textgreater}C polymorphism of the RAD51 gene. Moreover, there was a strong correlation between that genotype and endometrial cancer occurrence in subjects with a high level of basal DNA damage. We did not observe any correlation between the Ser326Cys polymorphism of the hOGG1 gene and endometrial cancer. Our result suggest that the 135G{\textgreater}C polymorphism of the RAD51 gene may be linked to endometrial cancer and can be considered as an additional marker of this disease.},
 author = {Krupa, Renata and Sobczuk, Anna and Popławski, Tomasz and Wozniak, Katarzyna and Blasiak, Janusz},
 doi = {10.1007/s11033-010-0214-z},
 issn = {1573-4978},
 journal = {Molecular Biology Reports},
 keywords = {Aged, Alleles, comet assay, DNA Damage, DNA Glycosylases, DNA Repair, Endometrial Neoplasms, Female, Genetic Markers, Genotype, Humans, Middle Aged, Polymorphism, Genetic, Polymorphism, Restriction Fragment Length, Rad51 Recombinase},
 language = {eng},
 month = {feb},
 number = {2},
 pages = {1163--1170},
 pmcid = {PMC3024515},
 pmid = {20602259},
 title = {{DNA} damage and repair in endometrial cancer in correlation with the {hOGG}1 and {RAD}51 genes polymorphism},
 volume = {38},
 year = {2011}
}

repository: naraoia/cv

repo_name: naraoia/cv


text:
@InProceedings{ding13,
  pdf = {http://jmlr.org/proceedings/papers/v28/ding13.pdf},
  supplementary = {Supplementary:ding13-supp.pdf},
  number = {3},
  section = {cycle-3},
  title = {Topic Discovery through Data Dependent and Random Projections},
  author = {Ding, Weicong and Hossein Rohban, Mohammad and Ishwar, Prakash and Saligrama, Venkatesh},
  pages = {1202-1210},
  abstract = {We present algorithms for topic modeling based on the geometry of cross-document word-frequency patterns. This perspective gains significance under the so called separability condition. This is a condition on existence of novel-words that are unique to each topic. We present a suite of highly efficient algorithms with provable guarantees based on data-dependent and random projections to identify novel words and associated topics. Our key insight here is that the maximum and minimum values of cross-document frequency patterns projected along any direction are associated with novel words. While our sample complexity bounds for topic recovery are similar to the state-of-art, the computational complexity of our random projection scheme scales linearly with the number of documents and the number of words per document. We present several experiments on synthetic and realworld datasets to demonstrate qualitative and quantitative merits of our scheme.},
}

repository: mreid/papersite

repo_name: mreid/papersite


text:
SUMMARY = "Universal character encoding detector for Python3"

PR = "${INC_PR}.0"

require chardet.inc

inherit setuptools python3native

DEPENDS += "python3-setuptools-native python3-wheel"

# Change install directory from "site-packages" to "dist-packages"
PYTHON_SITEPACKAGES_DIR = "${libdir}/${PYTHON_PN}/dist-packages"

do_install_append() {
	# remove unwanted files
	find ${D}${libdir} -type f -name "*.pyc" -exec rm -f {} \;
	rm -rf ${D}${libdir}/${PYTHON_PN}/dist-packages/chardet-2.3.0-py3.4.egg-info/SOURCES.txt

	# follow debian/rules
	mv ${D}${bindir}/chardetect ${D}${bindir}/chardetect3
}

#follow debian/control
RDEPENDS_${PN}_class-target += "python python3-pkg-resources"

BBCLASSEXTEND = "native"

repository: manut/meta-combo

repo_name: manut/meta-combo

branch_name: refs/heads/morty


text:
@inproceedings{management-conformance,
	author = "Soldani, Jacopo and Luthmann, Lars and Lochau, Malte and Brogi, Antonio",
	editor = "Brogi, Antonio and Zimmermann, Wolf and Kritikos, Kyriakos",
	title = "Testing Conformance in Multi-component Enterprise Application Management",
	booktitle = "Service-Oriented and Cloud Computing",
	year = "2020",
	publisher = "Springer International Publishing",
	address = "Cham",
	pages = "3--18"
}

repository: jsoldani/uni-page

repo_name: jsoldani/uni-page


text:
@article{baiSurveyStressReactions2004,
  title = {Survey of Stress Reactions among Health Care Workers Involved with the {{SARS}} Outbreak},
  author = {Bai, YaMei and Lin, Chao-Cheng and Lin, Chih-Yuan and Chen, Jen-Yeu and Chue, Ching-Mo and Chou, Pesus},
  year = {2004},
  month = sep,
  volume = {55},
  pages = {1055--1057},
  issn = {1075-2730},
  doi = {10.1176/appi.ps.55.9.1055},
  abstract = {The outbreak of severe acute respiratory syndrome (SARS) was unique because it was highly concentrated in health care settings and a large number of health care workers were infected. This study investigated stress reactions among 338 staff members in a hospital in East Taiwan that discontinued emergency and outpatient services to prevent possible nosocomial outbreak. Seventeen staff members (5 percent) suffered from an acute stress disorder; stepwise multiple logistic regression analysis determined that quarantine was the most related factor. Sixty-six staff members (20 percent) felt stigmatized and rejected in their neighborhood because of their hospital work, and 20 of 218 health care workers (9 percent) reported reluctance to work or had considered resignation.},
  journal = {Psychiatric Services (Washington, D.C.)},
  keywords = {Adult,Catchment Area; Health,Diagnostic and Statistical Manual of Mental Disorders,Disease Outbreaks,Female,Health Personnel,Hospitals,Humans,Male,Severe Acute Respiratory Syndrome,Stress; Psychological,Surveys and Questionnaires,Taiwan},
  language = {eng},
  number = {9},
  pmid = {15345768}
}

@article{lauPositiveMentalHealthrelated2006,
  title = {Positive Mental Health-Related Impacts of the {{SARS}} Epidemic on the General Public in {{Hong Kong}} and Their Associations with Other Negative Impacts},
  author = {Lau, Joseph T. F. and Yang, Xilin and Tsui, H. Y. and Pang, Ellie and Wing, Yun Kwok},
  year = {2006},
  month = aug,
  volume = {53},
  pages = {114--124},
  issn = {1532-2742},
  doi = {10.1016/j.jinf.2005.10.019},
  abstract = {OBJECTIVES: To investigate 2 positive impacts (better family/social support and lifestyle changes) and their associations with other negative impacts.
STUDY DESIGN AND PARTICIPANTS: A telephone survey using random telephone numbers and a structured questionnaire was conducted in Hong Kong general population. Eight hundred and eighteen Hong Kong residents of age 18-60 years completed the interview (response rate: 65\%) at around end of June 2003, the early ending phase of the epidemic.
RESULTS: Over 60\% of the respondents stated that they cared more about the family members' feelings; about 30\%-40\% stated that they found their friends, their family members more supportive or having more sharing with others when not feeling happy; only a few percent felt the opposite. Further, about 2/3 of the respondents paid more attention to their mental health. About 35\%-40\% took more time to rest, for relaxation or doing exercise. These items were, in general, negatively associated with post-traumatic stress, perception of stress and other perceptions that were related to SARS.
CONCLUSIONS: SARS have brought some positive impacts on social/family support, mental health awareness and lifestyle changes. These positive impacts were associated with other relevant negative impacts and might be important cushions of the negative impact.},
  journal = {The Journal of Infection},
  keywords = {Adolescent,Adult,Data Collection,Disease Outbreaks,Female,Health Behavior,Hong Kong,Humans,Male,Mental Health,Middle Aged,Odds Ratio,Severe Acute Respiratory Syndrome},
  language = {eng},
  number = {2},
  pmcid = {PMC7132442},
  pmid = {16343636}
}

@article{macgeorgeStressSocialSupport2004,
  title = {{Stress, social support, and health among college students after september 11, 2001}},
  author = {MacGeorge, Erina L. and Samter, Wendy and Feng, Bo and Gillihan, Seth J. and Graves, Angela R.},
  year = {2004},
  month = nov,
  volume = {45},
  pages = {655--670},
  publisher = {{Johns Hopkins University Press}},
  issn = {0897-5264},
  file = {/Users/emily/Zotero/storage/RFWCBDGP/stress-social-support-and-health-among-college-students-after-sep.html},
  journal = {Journal of College Student Development},
  language = {English (US)},
  number = {6}
}