text:
@article{bapna2019,
  title = {Non-{{Parametric Adaptation}} for {{Neural Machine Translation}}},
  author = {Bapna, Ankur and Firat, Orhan},
  year = {2019},
  journal = {arXiv},
  url = {http://arxiv.org/abs/1903.00058},
  abstract = {Neural Networks trained with gradient descent are known to be susceptible to catastrophic forgetting caused by parameter shift during the training process. In the context of Neural Machine Translation (NMT) this results in poor performance on heterogeneous datasets and on sub-tasks like rare phrase translation. On the other hand, non-parametric approaches are immune to forgetting, perfectly complementing the generalization ability of NMT. However, attempts to combine non-parametric or retrieval based approaches with NMT have only been successful on narrow domains, possibly due to over-reliance on sentence level retrieval. We propose a novel n-gram level retrieval approach that relies on local phrase level similarities, allowing us to retrieve neighbors that are useful for translation even when overall sentence similarity is low. We complement this with an expressive neural network, allowing our model to extract information from the noisy retrieved context. We evaluate our semi-parametric NMT approach on a heterogeneous dataset composed of WMT, IWSLT, JRC-Acquis and OpenSubtitles, and demonstrate gains on all 4 evaluation sets. The semi-parametric nature of our approach opens the door for non-parametric domain adaptation, demonstrating strong inference-time adaptation performance on new domains without the need for any parameter updates.},
  keywords = {[nlp],⛔ No DOI found},
  annotation = {\_eprint: 1903.00058}
}

@inproceedings{barrault2020,
  title = {Findings of the {{First Shared Task}} on {{Lifelong Learning Machine Translation}}},
  booktitle = {Proceedings of the {{Fifth Conference}} on {{Machine Translation}}},
  author = {Barrault, Lo{\"i}c and Biesialska, Magdalena and {Costa-juss{\`a}}, Marta R. and Bougares, Fethi and Galibert, Olivier},
  year = {2020},
  pages = {56--64},
  publisher = {{Association for Computational Linguistics}},
  address = {{Online}},
  url = {https://www.aclweb.org/anthology/2020.wmt-1.2},
  urldate = {2021-02-03},
  abstract = {A lifelong learning system can adapt to new data without forgetting previously acquired knowledge. In this paper, we introduce the first benchmark for lifelong learning machine translation. For this purpose, we provide training, lifelong and test data sets for two language pairs: English-German and English-French. Additionally, we report the results of our baseline systems, which we make available to the public. The goal of this shared task is to encourage research on the emerging topic of lifelong learning machine translation.},
  keywords = {[framework],[nlp],Active Learning,Continual Learning,Lifelong Learning,workshop}
}

@article{baweja2018,
  title = {Towards Continual Learning in Medical Imaging},
  author = {Baweja, Chaitanya and Glocker, Ben and Kamnitsas, Konstantinos},
  year = {2018},
  journal = {NeurIPS Workshop on Continual Learning},
  pages = {1--4},
  doi = {arXiv:1811.02496v1},
  url = {http://arxiv.org/abs/1811.02496},
  abstract = {This work investigates continual learning of two segmentation tasks in brain MRI with neural networks. To explore in this context the capabilities of current methods for countering catastrophic forgetting of the first task when a new one is learned, we investigate elastic weight consolidation, a recently proposed method based on Fisher information, originally evaluated on reinforcement learning of Atari games. We use it to sequentially learn segmentation of normal brain structures and then segmentation of white matter lesions. Our findings show this recent method reduces catastrophic forgetting, while large room for improvement exists in these challenging settings for continual learning.},
  keywords = {[vision],⚠ Invalid DOI},
  annotation = {\_eprint: 1811.02496}
}

@article{campo2020,
  title = {Continual {{Learning}} of {{Predictive Models}} in {{Video Sequences}} via {{Variational Autoencoders}}},
  author = {Campo, Damian and Slavic, Giulia and Baydoun, Mohamad and Marcenaro, Lucio and Regazzoni, Carlo},
  year = {2020},
  journal = {arXiv},
  url = {http://arxiv.org/abs/2006.01945},
  abstract = {This paper proposes a method for performing continual learning of predictive models that facilitate the inference of future frames in video sequences. For a first given experience, an initial Variational Autoencoder, together with a set of fully connected neural networks are utilized to respectively learn the appearance of video frames and their dynamics at the latent space level. By employing an adapted Markov Jump Particle Filter, the proposed method recognizes new situations and integrates them as predictive models avoiding catastrophic forgetting of previously learned tasks. For evaluating the proposed method, this article uses video sequences from a vehicle that performs different tasks in a controlled environment.},
  keywords = {[vision],⛔ No DOI found},
  annotation = {\_eprint: 2006.01945}
}

@inproceedings{carlson2010,
  title = {Toward an Architecture for Never-Ending Language Learning},
  booktitle = {Proceedings of the {{Twenty}}-{{Fourth AAAI Conference}} on {{Artificial Intelligence}}},
  author = {Carlson, Andrew and Betteridge, Justin and Kisiel, Bryan and Settles, Burr and Hruschka, Estevam R. and Mitchell, Tom M.},
  year = {2010},
  series = {{{AAAI}}'10},
  pages = {1306--1313},
  publisher = {{AAAI Press}},
  address = {{Atlanta, Georgia}},
  url = {https://www.aaai.org/ocs/index.php/AAAI/AAAI10/paper/view/1879},
  urldate = {2021-06-27},
  abstract = {We consider here the problem of building a never-ending language learner; that is, an intelligent computer agent that runs forever and that each day must (1) extract, or read, information from the web to populate a growing structured knowledge base, and (2) learn to perform this task better than on the previous day. In particular, we propose an approach and a set of design principles for such an agent, describe a partial implementation of such a system that has already learned to extract a knowledge base containing over 242,000 beliefs with an estimated precision of 74\% after running for 67 days, and discuss lessons learned from this preliminary attempt to build a never-ending learning agent.},
  keywords = {[nlp]}
}

@inproceedings{dautume2019,
  title = {Episodic {{Memory}} in {{Lifelong Language Learning}}},
  booktitle = {{{NeurIPS}}},
  author = {D'Autume, Cyprien de Masson and Ruder, Sebastian and Kong, Lingpeng and Yogatama, Dani},
  year = {2019},
  url = {http://arxiv.org/abs/1906.01076},
  abstract = {We introduce a lifelong language learning setup where a model needs to learn from a stream of text examples without any dataset identifier. We propose an episodic memory model that performs sparse experience replay and local adaptation to mitigate catastrophic forgetting in this setup. Experiments on text classification and question answering demonstrate the complementary benefits of sparse experience replay and local adaptation to allow the model to continuously learn from new datasets. We also show that the space complexity of the episodic memory module can be reduced significantly ({$\sim$}50-90\%) by randomly choosing which examples to store in memory with a minimal decrease in performance. We consider an episodic memory component as a crucial building block of general linguistic intelligence and see our model as a first step in that direction.},
  keywords = {[nlp]},
  annotation = {\_eprint: 1906.01076}
}

@article{delange2020a,
  title = {Unsupervised {{Model Personalization}} While {{Preserving Privacy}} and {{Scalability}}: An {{Open Problem}}},
  author = {De Lange, Matthias and Jia, Xu and Parisot, Sarah and Leonardis, Ales and Slabaugh, Gregory and Tuytelaars, Tinne},
  year = {2020},
  journal = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
  pages = {14451--14460},
  doi = {10.1109/cvpr42600.2020.01447},
  url = {http://arxiv.org/abs/2003.13296},
  abstract = {This work investigates the task of unsupervised model personalization, adapted to continually evolving, unlabeled local user images. We consider the practical scenario where a high capacity server interacts with a myriad of resource-limited edge devices, imposing strong requirements on scalability and local data privacy. We aim to address this challenge within the continual learning paradigm and provide a novel Dual User-Adaptation framework (DUA) to explore the problem. This framework flexibly disentangles user-adaptation into model personalization on the server and local data regularization on the user device, with desirable properties regarding scalability and privacy constraints. First, on the server, we introduce incremental learning of task-specific expert models, subsequently aggregated using a concealed unsupervised user prior. Aggregation avoids retraining, whereas the user prior conceals sensitive raw user data, and grants unsupervised adaptation. Second, local user-adaptation incorporates a domain adaptation point of view, adapting regularizing batch normalization parameters to the user data. We explore various empirical user configurations with different priors in categories and a tenfold of transforms for MIT Indoor Scene recognition, and classify numbers in a combined MNIST and SVHN setup. Extensive experiments yield promising results for data-driven local adaptation and elicit user priors for server adaptation to depend on the model rather than user data. Hence, although user-adaptation remains a challenging open problem, the DUA framework formalizes a principled foundation for personalizing both on server and user device, while maintaining privacy and scalability.},
  keywords = {[framework],[mnist],[vision]},
  annotation = {\_eprint: 2003.13296}
}

@article{fu2020,
  title = {Incremental {{Learning}} for {{End}}-to-{{End Automatic Speech Recognition}}},
  author = {Fu, Li and Li, Xiaoxiao and Zi, Libo},
  year = {2020},
  journal = {arXiv},
  url = {https://arxiv.org/abs/2005.04288},
  abstract = {\textdagger{} We propose an incremental learning for end-to-end Automatic Speech Recognition (ASR) to extend the model's capacity on a new task while retaining the performance on existing ones. The proposed method is effective without accessing to the old dataset to address the issues of high training cost and old dataset unavailability. To achieve this, knowledge distillation is applied as a guidance to retain the recognition ability from the previous model, which is then combined with the new ASR task for model optimization. With an ASR model pre-trained on 12,000h Mandarin speech, we test our proposed method on 300h new scenario task and 1h new named entities task. Experiments show that our method yields 3.25\% and 0.88\% absolute Character Error Rate (CER) reduction on the new scenario, when compared with the pre-trained model and the full-data retraining baseline, respectively. It even yields a surprising 0.37\% absolute CER reduction on the new scenario than the fine-tuning. For the new named entities task, our method significantly improves the accuracy compared with the pre-trained model, i.e. 16.95\% absolute CER reduction. For both of the new task adaptions, the new models still maintain a same accuracy with the baseline on the old tasks.},
  keywords = {[audio],⛔ No DOI found,end-to-end,incremental learning,Index Terms: automatic speech recognition,knowledge distillation}
}

@inproceedings{gupta2020a,
  title = {Neural {{Topic Modeling}} with {{Continual Lifelong Learning}}},
  booktitle = {{{ICML}}},
  author = {Gupta, Pankaj and Chaudhary, Yatin and Runkler, Thomas and Sch{\"u}tze, Hinrich},
  year = {2020},
  url = {http://arxiv.org/abs/2006.10909},
  abstract = {Lifelong learning has recently attracted attention in building machine learning systems that continually accumulate and transfer knowledge to help future learning. Unsupervised topic modeling has been popularly used to discover topics from document collections. However, the application of topic modeling is challenging due to data sparsity, e.g., in a small collection of (short) documents and thus, generate incoherent topics and sub-optimal document representations. To address the problem, we propose a lifelong learning framework for neural topic modeling that can continuously process streams of document collections, accumulate topics and guide future topic modeling tasks by knowledge transfer from several sources to better deal with the sparse data. In the lifelong process, we particularly investigate jointly: (1) sharing generative homologies (latent topics) over lifetime to transfer prior knowledge, and (2) minimizing catastrophic forgetting to retain the past learning via novel selective data augmentation, co-training and topic regularization approaches. Given a stream of document collections, we apply the proposed Lifelong Neural Topic Modeling (LNTM) framework in modeling three sparse document collections as future tasks and demonstrate improved performance quantified by perplexity, topic coherence and information retrieval task.},
  keywords = {[nlp]},
  annotation = {\_eprint: 2006.10909}
}

@inproceedings{hawkins2019,
  title = {Continual Adaptation for Efficient Machine Communication},
  booktitle = {Proceedings of the {{ICML Workshop}} on {{Adaptive}} \& {{Multitask Learning}}: Algorithms \& {{Systems}}},
  author = {Hawkins, Robert D and Kwon, Minae and Sadigh, Dorsa and Goodman, Noah D},
  year = {2019},
  url = {http://arxiv.org/abs/1911.09896},
  abstract = {To communicate with new partners in new contexts, humans rapidly form new linguistic conventions. Recent language models trained with deep neural networks are able to comprehend and produce the existing conventions present in their training data, but are not able to flexibly and interactively adapt those conventions on the fly as humans do. We introduce a repeated reference task as a benchmark for models of adaptation in communication and propose a regularized continual learning framework that allows an artificial agent initialized with a generic language model to more accurately and efficiently communicate with a partner over time. We evaluate this framework through simulations on COCO and in real-time reference game experiments with human partners.},
  annotation = {\_eprint: 1911.09896}
}

@incollection{kapoor2009,
  title = {Principles of {{Lifelong Learning}} for {{Predictive User Modeling}}},
  booktitle = {User {{Modeling}} 2007},
  author = {Kapoor, Ashish and Horvitz, Eric},
  year = {2009},
  pages = {37--46},
  publisher = {{Springer Berlin Heidelberg}},
  address = {{Berlin, Heidelberg}},
  issn = {03029743},
  doi = {10.1007/978-3-540-73078-1_7},
  url = {http://link.springer.com/10.1007/978-3-540-73078-1_7},
  isbn = {978-3-540-73077-4},
  pmid = {16717005}
}

@article{kiyasseh2020,
  title = {{{CLOPS}}: Continual {{Learning}} of {{Physiological Signals}}},
  author = {Kiyasseh, Dani and Zhu, Tingting and Clifton, David A},
  year = {2020},
  journal = {arXiv},
  url = {http://arxiv.org/abs/2004.09578},
  abstract = {Deep learning algorithms are known to experience destructive interference when instances violate the assumption of being independent and identically distributed (i.i.d). This violation, however, is ubiquitous in clinical settings where data are streamed temporally and from a multitude of physiological sensors. To overcome this obstacle, we propose CLOPS, a healthcare-specific replay-based continual learning strategy. In three continual learning scenarios based on three publically-available datasets, we show that CLOPS can outperform its multi-task learning counterpart. Moreover, we propose end-to-end trainable parameters, which we term task-instance parameters, that can be used to quantify task difficulty and similarity. This quantification yields insights into both network interpretability and clinical applications, where task difficulty is poorly quantified.},
  keywords = {⛔ No DOI found},
  annotation = {\_eprint: 2004.09578}
}

@article{lee2018,
  title = {Toward {{Continual Learning}} for {{Conversational Agents}}},
  author = {Lee, Sungjin},
  year = {2018},
  journal = {arXiv},
  url = {http://arxiv.org/abs/1712.09943},
  abstract = {While end-to-end neural conversation models have led to promising advances in reducing hand-crafted features and errors induced by the traditional complex system architecture, they typically require an enormous amount of data due to the lack of modularity. Previous studies adopted a hybrid approach with knowledge-based components either to abstract out domain-specific information or to augment data to cover more diverse patterns. On the contrary, we propose to directly address the problem using recent developments in the space of continual learning for neural models. Specifically, we adopt a domain-independent neural conversational model and introduce a novel neural continual learning algorithm that allows a conversational agent to accumulate skills across different tasks in a data-efficient way. To the best of our knowledge, this is the first work that applies continual learning to conversation systems. We verified the efficacy of our method through a conversational skill transfer from either synthetic dialogs or human-human dialogs to human-computer conversations in a customer support domain.},
  keywords = {[nlp],⛔ No DOI found,chatbot,Computer Science - Artificial Intelligence,Computer Science - Computation and Language,Computer Science - Human-Computer Interaction,conversation,conversational agent,ewc,lstm},
  note = {arXiv: 1712.09943}
}

@article{lee2020,
  title = {Clinical Applications of Continual Learning Machine Learning},
  author = {Lee, Cecilia S and Lee, Aaron Y},
  year = {2020},
  journal = {The Lancet Digital Health},
  volume = {2},
  number = {6},
  pages = {e279--e281},
  issn = {25897500},
  doi = {10.1016/S2589-7500(20)30102-3},
  url = {https://linkinghub.elsevier.com/retrieve/pii/S2589750020301023}
}

@article{lenga2020,
  title = {Continual {{Learning}} for {{Domain Adaptation}} in {{Chest X}}-Ray {{Classification}}},
  author = {Lenga, Matthias and Schulz, Heinrich and Saalbach, Axel},
  year = {2020},
  journal = {arXiv},
  pages = {1--11},
  url = {http://arxiv.org/abs/2001.05922},
  abstract = {Over the last years, Deep Learning has been successfully applied to a broad range of medical applications. Especially in the context of chest X-ray classification, results have been reported which are on par, or even superior to experienced radiologists. Despite this success in controlled experimental environments, it has been noted that the ability of Deep Learning models to generalize to data from a new domain (with potentially different tasks) is often limited. In order to address this challenge, we investigate techniques from the field of Continual Learning (CL) including Joint Training (JT), Elastic Weight Consolidation (EWC) and Learning Without Forgetting (LWF). Using the ChestX-ray14 and the MIMIC-CXR datasets, we demonstrate empirically that these methods provide promising options to improve the performance of Deep Learning models on a target domain and to mitigate effectively catastrophic forgetting for the source domain. To this end, the best overall performance was obtained using JT, while for LWF competitive results could be achieved - even without accessing data from the source domain.},
  keywords = {[vision],⛔ No DOI found,catastrophic forgetting,chest x-ray,chestx-ray14,continual learning,convolutional neural networks,elastic weight consolidation,joint training,learning without forgetting,mimic-cxr},
  annotation = {\_eprint: 2001.05922}
}

@inproceedings{liu2019,
  title = {Continual {{Learning}} for {{Sentence Representations Using Conceptors}}},
  booktitle = {{{NAACL}}},
  author = {Liu, Tianlin and Ungar, Lyle and Sedoc, Jo{\~a}o},
  year = {2019},
  doi = {10.18653/v1/N19-1331},
  url = {http://arxiv.org/abs/1904.09187},
  abstract = {Distributed representations of sentences have become ubiquitous in natural language processing tasks. In this paper, we consider a continual learning scenario for sentence representations: Given a sequence of corpora, we aim to optimize the sentence encoder with respect to the new corpus while maintaining its accuracy on the old corpora. To address this problem, we propose to initialize sentence encoders with the help of corpus-independent features, and then sequentially update sentence encoders using Boolean operations of conceptor matrices to learn corpus-dependent features. We evaluate our approach on semantic textual similarity tasks and show that our proposed sentence encoder can continually learn features from new corpora while retaining its competence on previously encountered corpora.},
  keywords = {[nlp]},
  annotation = {\_eprint: 1904.09187}
}

@article{madasu2020,
  title = {Sequential {{Domain Adaptation}} through {{Elastic Weight Consolidation}} for {{Sentiment Analysis}}},
  author = {Madasu, Avinash and Rao, Vijjini Anvesh},
  year = {2020},
  journal = {arXiv},
  eprint = {2007.01189},
  eprinttype = {arxiv},
  url = {http://arxiv.org/abs/2007.01189},
  urldate = {2021-01-08},
  abstract = {Elastic Weight Consolidation (EWC) is a technique used in overcoming catastrophic forgetting between successive tasks trained on a neural network. We use this phenomenon of information sharing between tasks for domain adaptation. Training data for tasks such as sentiment analysis (SA) may not be fairly represented across multiple domains. Domain Adaptation (DA) aims to build algorithms that leverage information from source domains to facilitate performance on an unseen target domain. We propose a model-independent framework - Sequential Domain Adaptation (SDA). SDA draws on EWC for training on successive source domains to move towards a general domain solution, thereby solving the problem of domain adaptation. We test SDA on convolutional, recurrent, and attention-based architectures. Our experiments show that the proposed framework enables simple architectures such as CNNs to outperform complex state-of-the-art models in domain adaptation of SA. In addition, we observe that the effectiveness of a harder first Anti-Curriculum ordering of source domains leads to maximum performance.},
  archiveprefix = {arXiv},
  keywords = {[nlp],[rnn],⛔ No DOI found,Computer Science - Computation and Language},
  note = {Comment: Accepted at 25th International Conference on Pattern Recognition, January 2021, Milan, Italy}
}

@inproceedings{mazumder2019,
  title = {Lifelong and {{Interactive Learning}} of {{Factual Knowledge}} in {{Dialogues}}},
  booktitle = {Proceedings of the 20th {{Annual SIGdial Meeting}} on {{Discourse}} and {{Dialogue}}},
  author = {Mazumder, Sahisnu and Liu, Bing and Wang, Shuai and Ma, Nianzu},
  year = {2019},
  pages = {21--31},
  publisher = {{Association for Computational Linguistics}},
  address = {{Stroudsburg, PA, USA}},
  doi = {10.18653/v1/W19-5903},
  url = {http://arxiv.org/abs/1907.13295 https://www.aclweb.org/anthology/W19-5903},
  abstract = {Dialogue systems are increasingly using knowledge bases (KBs) storing real-world facts to help generate quality responses. However, as the KBs are inherently incomplete and remain fixed during conversation, it limits dialogue systems' ability to answer questions and to handle questions involving entities or relations that are not in the KB. In this paper, we make an attempt to propose an engine for Continuous and Interactive Learning of Knowledge (CILK) for dialogue systems to give them the ability to continuously and interactively learn and infer new knowledge during conversations. With more knowledge accumulated over time, they will be able to learn better and answer more questions. Our empirical evaluation shows that CILK is promising.},
  keywords = {[nlp]},
  annotation = {\_eprint: 1907.13295}
}

@inproceedings{NEURIPS2020_c2964caa,
  title = {{{RATT}}: Recurrent Attention to Transient Tasks for Continual Image Captioning},
  booktitle = {Advances in Neural Information Processing Systems},
  author = {Del Chiaro, Riccardo and Twardowski, Bart{\l}omiej and Bagdanov, Andrew and {van de Weijer}, Joost},
  editor = {Larochelle, H. and Ranzato, M. and Hadsell, R. and Balcan, M. F. and Lin, H.},
  year = {2020},
  volume = {33},
  pages = {16736--16748},
  publisher = {{Curran Associates, Inc.}},
  url = {https://proceedings.neurips.cc/paper/2020/file/c2964caac096f26db222cb325aa267cb-Paper.pdf},
  keywords = {[nlp],⛔ No DOI found}
}

@article{ozgun2020,
  title = {Importance {{Driven Continual Learning}} for {{Segmentation Across Domains}}},
  author = {{\"O}zg{\"u}n, Sinan {\"O}zg{\"u}r and Rickmann, Anne-Marie and Roy, Abhijit Guha and Wachinger, Christian},
  year = {2020},
  journal = {arXiv},
  pages = {1--10},
  url = {http://arxiv.org/abs/2005.00079},
  abstract = {The ability of neural networks to continuously learn and adapt to new tasks while retaining prior knowledge is crucial for many applications. However, current neural networks tend to forget previously learned tasks when trained on new ones, i.e., they suffer from Catastrophic Forgetting (CF). The objective of Continual Learning (CL) is to alleviate this problem, which is particularly relevant for medical applications, where it may not be feasible to store and access previously used sensitive patient data. In this work, we propose a Continual Learning approach for brain segmentation, where a single network is consecutively trained on samples from different domains. We build upon an importance driven approach and adapt it for medical image segmentation. Particularly, we introduce learning rate regularization to prevent the loss of the network's knowledge. Our results demonstrate that directly restricting the adaptation of important network parameters clearly reduces Catastrophic Forgetting for segmentation across domains.},
  keywords = {[vision],⛔ No DOI found},
  annotation = {\_eprint: 2005.00079}
}

@article{philps2019,
  title = {Making {{Good}} on {{LSTMs}}' {{Unfulfilled Promise}}},
  author = {Philps, Daniel and d'Avila Garcez, Artur and Weyde, Tillman},
  year = {2019},
  journal = {arXiv},
  eprint = {1911.04489},
  eprinttype = {arxiv},
  url = {http://arxiv.org/abs/1911.04489},
  urldate = {2021-01-08},
  abstract = {LSTMs promise much to financial time-series analysis, temporal and cross-sectional inference, but we find that they do not deliver in a real-world financial management task. We examine an alternative called Continual Learning (CL), a memory-augmented approach, which can provide transparent explanations, i.e. which memory did what and when. This work has implications for many financial applications including credit, time-varying fairness in decision making and more. We make three important new observations. Firstly, as well as being more explainable, time-series CL approaches outperform LSTMs as well as a simple sliding window learner using feed-forward neural networks (FFNN). Secondly, we show that CL based on a sliding window learner (FFNN) is more effective than CL based on a sequential learner (LSTM). Thirdly, we examine how real-world, time-series noise impacts several similarity approaches used in CL memory addressing. We provide these insights using an approach called Continual Learning Augmentation (CLA) tested on a complex real-world problem, emerging market equities investment decision making. CLA provides a test-bed as it can be based on different types of time-series learners, allowing testing of LSTM and FFNN learners side by side. CLA is also used to test several distance approaches used in a memory recall-gate: Euclidean distance (ED), dynamic time warping (DTW), auto-encoders (AE) and a novel hybrid approach, warp-AE. We find that ED under-performs DTW and AE but warp-AE shows the best overall performance in a real-world financial task.},
  archiveprefix = {arXiv},
  keywords = {[rnn],⛔ No DOI found,Computer Science - Machine Learning,Quantitative Finance - Computational Finance,Quantitative Finance - Portfolio Management,Statistics - Machine Learning},
  note = {Comment: 33rd Conference on Neural Information Processing Systems (NeurIPS 2019), Vancouver, Canada. arXiv admin note: text overlap with arXiv:1812.02340}
}

@article{shao2021,
  title = {The {{Traffic Flow Prediction Method Using}} the {{Incremental Learning}}-{{Based CNN}}-{{LTSM Model}}: The {{Solution}} of {{Mobile Application}}},
  shorttitle = {The {{Traffic Flow Prediction Method Using}} the {{Incremental Learning}}-{{Based CNN}}-{{LTSM Model}}},
  author = {Shao, Yanli and Zhao, Yiming and Yu, Feng and Zhu, Huawei and Fang, Jinglong},
  year = {2021},
  journal = {Mobile Information Systems},
  volume = {2021},
  pages = {e5579451},
  publisher = {{Hindawi}},
  issn = {1574-017X},
  doi = {10.1155/2021/5579451},
  url = {https://www.hindawi.com/journals/misy/2021/5579451/},
  urldate = {2021-06-05},
  abstract = {With the acceleration of urbanization and the increase in the number of motor vehicles, more and more social problems such as traffic congestion have emerged. Accordingly, efficient and accurate traffic flow prediction has become a research hot spot in the field of intelligent transportation. However, traditional machine learning algorithms cannot further optimize the model with the increase of the data scale, and the deep learning algorithms perform poorly in mobile application or real-time application; how to train and update deep learning models efficiently and accurately is still an urgent problem since they require huge computation resources and time costs. Therefore, an incremental learning-based CNN-LTSM model, IL-TFNet, is proposed for traffic flow prediction in this study. The lightweight convolution neural network-based model architecture is designed to process spatiotemporal and external environment features simultaneously to improve the prediction performance and prediction efficiency of the model. Especially, the K-means clustering algorithm is applied as an uncertainty feature to extract unknown traffic accident information. During the model training, instead of the traditional batch learning algorithm, the incremental learning algorithm is applied to reduce the cost of updating the model and satisfy the requirements of high real-time performance and low computational overhead in short-term traffic prediction. Furthermore, the idea of combining incremental learning with active learning is proposed to fine-tune the prediction model to improve prediction accuracy in special situations. Experiments have proved that compared with other traffic flow prediction models, the IL-TFNet model performs well in short-term traffic flow prediction.},
  langid = {english},
  keywords = {[experimental]}
}

@inproceedings{sun2020,
  title = {{{LAMOL}}: {{LAnguage MOdeling}} for {{Lifelong Language Learning}}},
  shorttitle = {{{LAMOL}}},
  booktitle = {{{ICLR}}},
  author = {Sun, Fan-Keng and Ho, Cheng-Hao and Lee, Hung-Yi},
  year = {2020},
  url = {https://openreview.net/forum?id=Skgxcn4YDS},
  abstract = {Most research on lifelong learning applies to images or games, but not language. We present LAMOL, a simple yet effective method for lifelong language learning (LLL) based on language...},
  keywords = {[nlp]}
}

@inproceedings{thompson2019,
  title = {Overcoming {{Catastrophic Forgetting During Domain Adaptation}} of {{Neural Machine Translation}}},
  booktitle = {Proceedings of the 2019 {{Conference}} of the {{North American Chapter}} of the {{Association}} for {{Computational Linguistics}}: Human {{Language Technologies}}, {{Volume}} 1 ({{Long}} and {{Short Papers}})},
  author = {Thompson, Brian and Gwinnup, Jeremy and Khayrallah, Huda and Duh, Kevin and Koehn, Philipp},
  year = {2019},
  pages = {2062--2068},
  publisher = {{Association for Computational Linguistics}},
  address = {{Minneapolis, Minnesota}},
  doi = {10.18653/v1/N19-1209},
  url = {https://www.aclweb.org/anthology/N19-1209},
  urldate = {2021-01-08},
  abstract = {Continued training is an effective method for domain adaptation in neural machine translation. However, in-domain gains from adaptation come at the expense of general-domain performance. In this work, we interpret the drop in general-domain performance as catastrophic forgetting of general-domain knowledge. To mitigate it, we adapt Elastic Weight Consolidation (EWC)\textemdash a machine learning method for learning a new task without forgetting previous tasks. Our method retains the majority of general-domain performance lost in continued training without degrading in-domain performance, outperforming the previous state-of-the-art. We also explore the full range of general-domain performance available when some in-domain degradation is acceptable.},
  keywords = {[nlp],[rnn]}
}

@article{zhai2019,
  title = {Lifelong {{Learning}} for {{Scene Recognition}} in {{Remote Sensing Images}}},
  author = {Zhai, Min and Liu, Huaping and Sun, Fuchun},
  year = {2019},
  journal = {IEEE Geoscience and Remote Sensing Letters},
  volume = {16},
  number = {9},
  pages = {1472--1476},
  publisher = {{IEEE}},
  issn = {1545-598X},
  doi = {10.1109/LGRS.2019.2897652},
  url = {https://ieeexplore.ieee.org/document/8662768/},
  abstract = {The development of visual sensing technologies has made it possible to obtain some high resolution and to gather many high-resolution satellite images. To make the best use of these images, it is essential to be able to recognize and retrieve their intrinsic scene information. The problem of scene recognition in remote sensing images has recently aroused considerable interest, mainly due to the great success achieved by deep learning methods in generic image classification. Nevertheless, such methods usually require large amounts of labeled data. By contrast, remote sensing images are relatively scarce and expensive to obtain. Moreover, data sets from different aerospace research institutions exhibit large disparities. In order to address these problems, we propose a model based on a meta-learning method with the ability of learning a classifier from just few-shot samples. With the proposed model, the knowledge learned from one data set can be easily adapted to a new data set, which, in turn, would serve in the lifelong few-shot learning. Scene-level image recognition experiments, on public high-resolution remote sensing image data sets, validate our proposed lifelong few-shot learning model.},
  keywords = {[vision]}
}


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

package protos // import "magma/lte/cloud/go/protos"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import protos "magma/orc8r/cloud/go/protos"

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

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// --------------------------------------------------------------------------
// Message Definitions for TR-069 message injection. This is used for manual
// testing of the TR-069 server.
// --------------------------------------------------------------------------
type GetParameterRequest struct {
	// Serial ID of eNodeB. Uniquely identifies the eNodeB.
	DeviceSerial string `protobuf:"bytes,1,opt,name=device_serial,json=deviceSerial,proto3" json:"device_serial,omitempty"`
	// Fully qualified parameter name, e.g:
	// InternetGatewayDevice.LANDevice.1.Hosts.
	ParameterName        string   `protobuf:"bytes,2,opt,name=parameter_name,json=parameterName,proto3" json:"parameter_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetParameterRequest proto.InternalMessageInfo

func (m *GetParameterRequest) GetDeviceSerial() string {
	if m != nil {
		return m.DeviceSerial
	}
	return ""
}

func (m *GetParameterRequest) GetParameterName() string {
	if m != nil {
		return m.ParameterName
	}
	return ""
}

type NameValue struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Note: parameter value is always passed back as string. Up to calling
	// function to determine type
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NameValue proto.InternalMessageInfo

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

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

type GetParameterResponse struct {
	DeviceSerial         string       `protobuf:"bytes,1,opt,name=device_serial,json=deviceSerial,proto3" json:"device_serial,omitempty"`
	Parameters           []*NameValue `protobuf:"bytes,2,rep,name=parameters,proto3" json:"parameters,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_GetParameterResponse proto.InternalMessageInfo

func (m *GetParameterResponse) GetDeviceSerial() string {
	if m != nil {
		return m.DeviceSerial
	}
	return ""
}

func (m *GetParameterResponse) GetParameters() []*NameValue {
	if m != nil {
		return m.Parameters
	}
	return nil
}

type SetParameterRequest struct {
	// Serial ID of eNodeB. Uniquely identifies the eNodeB.
	DeviceSerial string `protobuf:"bytes,1,opt,name=device_serial,json=deviceSerial,proto3" json:"device_serial,omitempty"`
	// Fully qualified parameter name, e.g:
	// InternetGatewayDevice.LANDevice.1.Hosts.
	ParameterName string `protobuf:"bytes,2,opt,name=parameter_name,json=parameterName,proto3" json:"parameter_name,omitempty"`
	// Data values for each data type
	//
	// Types that are valid to be assigned to Value:
	//	*SetParameterRequest_ValueInt
	//	*SetParameterRequest_ValueString
	//	*SetParameterRequest_ValueBool
	Value isSetParameterRequest_Value `protobuf_oneof:"value"`
	// Key to be used at ACS discretion to determine when parameter was last
	// updated
	ParameterKey         string   `protobuf:"bytes,6,opt,name=parameter_key,json=parameterKey,proto3" json:"parameter_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SetParameterRequest proto.InternalMessageInfo

func (m *SetParameterRequest) GetDeviceSerial() string {
	if m != nil {
		return m.DeviceSerial
	}
	return ""
}

func (m *SetParameterRequest) GetParameterName() string {
	if m != nil {
		return m.ParameterName
	}
	return ""
}

type isSetParameterRequest_Value interface {
	isSetParameterRequest_Value()
}

type SetParameterRequest_ValueInt struct {
	ValueInt int32 `protobuf:"varint,3,opt,name=value_int,json=valueInt,proto3,oneof"`
}

type SetParameterRequest_ValueString struct {
	ValueString string `protobuf:"bytes,4,opt,name=value_string,json=valueString,proto3,oneof"`
}

type SetParameterRequest_ValueBool struct {
	ValueBool bool `protobuf:"varint,5,opt,name=value_bool,json=valueBool,proto3,oneof"`
}

func (*SetParameterRequest_ValueInt) isSetParameterRequest_Value() {}

func (*SetParameterRequest_ValueString) isSetParameterRequest_Value() {}

func (*SetParameterRequest_ValueBool) isSetParameterRequest_Value() {}

func (m *SetParameterRequest) GetValue() isSetParameterRequest_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *SetParameterRequest) GetValueInt() int32 {
	if x, ok := m.GetValue().(*SetParameterRequest_ValueInt); ok {
		return x.ValueInt
	}
	return 0
}

func (m *SetParameterRequest) GetValueString() string {
	if x, ok := m.GetValue().(*SetParameterRequest_ValueString); ok {
		return x.ValueString
	}
	return ""
}

func (m *SetParameterRequest) GetValueBool() bool {
	if x, ok := m.GetValue().(*SetParameterRequest_ValueBool); ok {
		return x.ValueBool
	}
	return false
}

func (m *SetParameterRequest) GetParameterKey() string {
	if m != nil {
		return m.ParameterKey
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*SetParameterRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _SetParameterRequest_OneofMarshaler, _SetParameterRequest_OneofUnmarshaler, _SetParameterRequest_OneofSizer, []interface{}{
		(*SetParameterRequest_ValueInt)(nil),
		(*SetParameterRequest_ValueString)(nil),
		(*SetParameterRequest_ValueBool)(nil),
	}
}

func _SetParameterRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*SetParameterRequest)
	// value
	switch x := m.Value.(type) {
	case *SetParameterRequest_ValueInt:
		b.EncodeVarint(3<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.ValueInt))
	case *SetParameterRequest_ValueString:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.ValueString)
	case *SetParameterRequest_ValueBool:
		t := uint64(0)
		if x.ValueBool {
			t = 1
		}
		b.EncodeVarint(5<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case nil:
	default:
		return fmt.Errorf("SetParameterRequest.Value has unexpected type %T", x)
	}
	return nil
}

func _SetParameterRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*SetParameterRequest)
	switch tag {
	case 3: // value.value_int
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &SetParameterRequest_ValueInt{int32(x)}
		return true, err
	case 4: // value.value_string
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Value = &SetParameterRequest_ValueString{x}
		return true, err
	case 5: // value.value_bool
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &SetParameterRequest_ValueBool{x != 0}
		return true, err
	default:
		return false, nil
	}
}

func _SetParameterRequest_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*SetParameterRequest)
	// value
	switch x := m.Value.(type) {
	case *SetParameterRequest_ValueInt:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.ValueInt))
	case *SetParameterRequest_ValueString:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.ValueString)))
		n += len(x.ValueString)
	case *SetParameterRequest_ValueBool:
		n += 1 // tag and wire
		n += 1
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type EnodebIdentity struct {
	// Serial ID of eNodeB. Uniquely identifies the eNodeB.
	DeviceSerial         string   `protobuf:"bytes,1,opt,name=device_serial,json=deviceSerial,proto3" json:"device_serial,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_EnodebIdentity proto.InternalMessageInfo

func (m *EnodebIdentity) GetDeviceSerial() string {
	if m != nil {
		return m.DeviceSerial
	}
	return ""
}

type AllEnodebStatus struct {
	EnbStatusList        []*SingleEnodebStatus `protobuf:"bytes,1,rep,name=enb_status_list,json=enbStatusList,proto3" json:"enb_status_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

var xxx_messageInfo_AllEnodebStatus proto.InternalMessageInfo

func (m *AllEnodebStatus) GetEnbStatusList() []*SingleEnodebStatus {
	if m != nil {
		return m.EnbStatusList
	}
	return nil
}

type SingleEnodebStatus struct {
	DeviceSerial         string   `protobuf:"bytes,1,opt,name=device_serial,json=deviceSerial,proto3" json:"device_serial,omitempty"`
	IpAddress            string   `protobuf:"bytes,2,opt,name=ip_address,json=ipAddress,proto3" json:"ip_address,omitempty"`
	Connected            string   `protobuf:"bytes,3,opt,name=connected,proto3" json:"connected,omitempty"`
	Configured           string   `protobuf:"bytes,4,opt,name=configured,proto3" json:"configured,omitempty"`
	OpstateEnabled       string   `protobuf:"bytes,5,opt,name=opstate_enabled,json=opstateEnabled,proto3" json:"opstate_enabled,omitempty"`
	RfTxOn               string   `protobuf:"bytes,6,opt,name=rf_tx_on,json=rfTxOn,proto3" json:"rf_tx_on,omitempty"`
	GpsConnected         string   `protobuf:"bytes,7,opt,name=gps_connected,json=gpsConnected,proto3" json:"gps_connected,omitempty"`
	PtpConnected         string   `protobuf:"bytes,8,opt,name=ptp_connected,json=ptpConnected,proto3" json:"ptp_connected,omitempty"`
	MmeConnected         string   `protobuf:"bytes,9,opt,name=mme_connected,json=mmeConnected,proto3" json:"mme_connected,omitempty"`
	GpsLongitude         string   `protobuf:"bytes,10,opt,name=gps_longitude,json=gpsLongitude,proto3" json:"gps_longitude,omitempty"`
	GpsLatitude          string   `protobuf:"bytes,11,opt,name=gps_latitude,json=gpsLatitude,proto3" json:"gps_latitude,omitempty"`
	FsmState             string   `protobuf:"bytes,12,opt,name=fsm_state,json=fsmState,proto3" json:"fsm_state,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SingleEnodebStatus proto.InternalMessageInfo

func (m *SingleEnodebStatus) GetDeviceSerial() string {
	if m != nil {
		return m.DeviceSerial
	}
	return ""
}

func (m *SingleEnodebStatus) GetIpAddress() string {
	if m != nil {
		return m.IpAddress
	}
	return ""
}

func (m *SingleEnodebStatus) GetConnected() string {
	if m != nil {
		return m.Connected
	}
	return ""
}

func (m *SingleEnodebStatus) GetConfigured() string {
	if m != nil {
		return m.Configured
	}
	return ""
}

func (m *SingleEnodebStatus) GetOpstateEnabled() string {
	if m != nil {
		return m.OpstateEnabled
	}
	return ""
}

func (m *SingleEnodebStatus) GetRfTxOn() string {
	if m != nil {
		return m.RfTxOn
	}
	return ""
}

func (m *SingleEnodebStatus) GetGpsConnected() string {
	if m != nil {
		return m.GpsConnected
	}
	return ""
}

func (m *SingleEnodebStatus) GetPtpConnected() string {
	if m != nil {
		return m.PtpConnected
	}
	return ""
}

func (m *SingleEnodebStatus) GetMmeConnected() string {
	if m != nil {
		return m.MmeConnected
	}
	return ""
}

func (m *SingleEnodebStatus) GetGpsLongitude() string {
	if m != nil {
		return m.GpsLongitude
	}
	return ""
}

func (m *SingleEnodebStatus) GetGpsLatitude() string {
	if m != nil {
		return m.GpsLatitude
	}
	return ""
}

func (m *SingleEnodebStatus) GetFsmState() string {
	if m != nil {
		return m.FsmState
	}
	return ""
}

func init() {
	proto.RegisterType((*GetParameterRequest)(nil), "magma.lte.GetParameterRequest")
	proto.RegisterType((*NameValue)(nil), "magma.lte.NameValue")
	proto.RegisterType((*GetParameterResponse)(nil), "magma.lte.GetParameterResponse")
	proto.RegisterType((*SetParameterRequest)(nil), "magma.lte.SetParameterRequest")
	proto.RegisterType((*EnodebIdentity)(nil), "magma.lte.EnodebIdentity")
	proto.RegisterType((*AllEnodebStatus)(nil), "magma.lte.AllEnodebStatus")
	proto.RegisterType((*SingleEnodebStatus)(nil), "magma.lte.SingleEnodebStatus")
}

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

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

// EnodebdClient is the client API for Enodebd service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type EnodebdClient interface {
	// Sends GetParameterValues message to ENodeB. TR-069 supports multiple
	// parameter names per message, but only one is supported here.
	GetParameter(ctx context.Context, in *GetParameterRequest, opts ...grpc.CallOption) (*GetParameterResponse, error)
	// Sends SetParameterValues message to ENodeB. TR-069 supports multiple
	// parameter names per message, but only one is supported here.
	SetParameter(ctx context.Context, in *SetParameterRequest, opts ...grpc.CallOption) (*protos.Void, error)
	// Configure eNodeB based on enodebd config file
	Configure(ctx context.Context, in *EnodebIdentity, opts ...grpc.CallOption) (*protos.Void, error)
	// Reboot eNodeB
	Reboot(ctx context.Context, in *EnodebIdentity, opts ...grpc.CallOption) (*protos.Void, error)
	// Reboot every connected eNodeB
	RebootAll(ctx context.Context, in *protos.Void, opts ...grpc.CallOption) (*protos.Void, error)
	// Get current status
	GetStatus(ctx context.Context, in *protos.Void, opts ...grpc.CallOption) (*protos.ServiceStatus, error)
	// Get status info for all connected eNodeB devices
	GetAllEnodebStatus(ctx context.Context, in *protos.Void, opts ...grpc.CallOption) (*AllEnodebStatus, error)
	// Get status info of a single connected eNodeB device
	GetEnodebStatus(ctx context.Context, in *EnodebIdentity, opts ...grpc.CallOption) (*SingleEnodebStatus, error)
}

type enodebdClient struct {
	cc *grpc.ClientConn
}

func NewEnodebdClient(cc *grpc.ClientConn) EnodebdClient {
	return &enodebdClient{cc}
}

func (c *enodebdClient) GetParameter(ctx context.Context, in *GetParameterRequest, opts ...grpc.CallOption) (*GetParameterResponse, error) {
	out := new(GetParameterResponse)
	err := c.cc.Invoke(ctx, "/magma.lte.Enodebd/GetParameter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *enodebdClient) SetParameter(ctx context.Context, in *SetParameterRequest, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.lte.Enodebd/SetParameter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *enodebdClient) Configure(ctx context.Context, in *EnodebIdentity, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.lte.Enodebd/Configure", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *enodebdClient) Reboot(ctx context.Context, in *EnodebIdentity, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.lte.Enodebd/Reboot", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *enodebdClient) RebootAll(ctx context.Context, in *protos.Void, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.lte.Enodebd/RebootAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *enodebdClient) GetStatus(ctx context.Context, in *protos.Void, opts ...grpc.CallOption) (*protos.ServiceStatus, error) {
	out := new(protos.ServiceStatus)
	err := c.cc.Invoke(ctx, "/magma.lte.Enodebd/GetStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *enodebdClient) GetAllEnodebStatus(ctx context.Context, in *protos.Void, opts ...grpc.CallOption) (*AllEnodebStatus, error) {
	out := new(AllEnodebStatus)
	err := c.cc.Invoke(ctx, "/magma.lte.Enodebd/GetAllEnodebStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *enodebdClient) GetEnodebStatus(ctx context.Context, in *EnodebIdentity, opts ...grpc.CallOption) (*SingleEnodebStatus, error) {
	out := new(SingleEnodebStatus)
	err := c.cc.Invoke(ctx, "/magma.lte.Enodebd/GetEnodebStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// EnodebdServer is the server API for Enodebd service.
type EnodebdServer interface {
	// Sends GetParameterValues message to ENodeB. TR-069 supports multiple
	// parameter names per message, but only one is supported here.
	GetParameter(context.Context, *GetParameterRequest) (*GetParameterResponse, error)
	// Sends SetParameterValues message to ENodeB. TR-069 supports multiple
	// parameter names per message, but only one is supported here.
	SetParameter(context.Context, *SetParameterRequest) (*protos.Void, error)
	// Configure eNodeB based on enodebd config file
	Configure(context.Context, *EnodebIdentity) (*protos.Void, error)
	// Reboot eNodeB
	Reboot(context.Context, *EnodebIdentity) (*protos.Void, error)
	// Reboot every connected eNodeB
	RebootAll(context.Context, *protos.Void) (*protos.Void, error)
	// Get current status
	GetStatus(context.Context, *protos.Void) (*protos.ServiceStatus, error)
	// Get status info for all connected eNodeB devices
	GetAllEnodebStatus(context.Context, *protos.Void) (*AllEnodebStatus, error)
	// Get status info of a single connected eNodeB device
	GetEnodebStatus(context.Context, *EnodebIdentity) (*SingleEnodebStatus, error)
}

func RegisterEnodebdServer(s *grpc.Server, srv EnodebdServer) {
	s.RegisterService(&_Enodebd_serviceDesc, srv)
}

func _Enodebd_GetParameter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetParameterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EnodebdServer).GetParameter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.Enodebd/GetParameter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EnodebdServer).GetParameter(ctx, req.(*GetParameterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Enodebd_SetParameter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetParameterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EnodebdServer).SetParameter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.Enodebd/SetParameter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EnodebdServer).SetParameter(ctx, req.(*SetParameterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Enodebd_Configure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnodebIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EnodebdServer).Configure(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.Enodebd/Configure",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EnodebdServer).Configure(ctx, req.(*EnodebIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Enodebd_Reboot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnodebIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EnodebdServer).Reboot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.Enodebd/Reboot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EnodebdServer).Reboot(ctx, req.(*EnodebIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Enodebd_RebootAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Void)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EnodebdServer).RebootAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.Enodebd/RebootAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EnodebdServer).RebootAll(ctx, req.(*protos.Void))
	}
	return interceptor(ctx, in, info, handler)
}

func _Enodebd_GetStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Void)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EnodebdServer).GetStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.Enodebd/GetStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EnodebdServer).GetStatus(ctx, req.(*protos.Void))
	}
	return interceptor(ctx, in, info, handler)
}

func _Enodebd_GetAllEnodebStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(protos.Void)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EnodebdServer).GetAllEnodebStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.Enodebd/GetAllEnodebStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EnodebdServer).GetAllEnodebStatus(ctx, req.(*protos.Void))
	}
	return interceptor(ctx, in, info, handler)
}

func _Enodebd_GetEnodebStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnodebIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EnodebdServer).GetEnodebStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.Enodebd/GetEnodebStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EnodebdServer).GetEnodebStatus(ctx, req.(*EnodebIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

var _Enodebd_serviceDesc = grpc.ServiceDesc{
	ServiceName: "magma.lte.Enodebd",
	HandlerType: (*EnodebdServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetParameter",
			Handler:    _Enodebd_GetParameter_Handler,
		},
		{
			MethodName: "SetParameter",
			Handler:    _Enodebd_SetParameter_Handler,
		},
		{
			MethodName: "Configure",
			Handler:    _Enodebd_Configure_Handler,
		},
		{
			MethodName: "Reboot",
			Handler:    _Enodebd_Reboot_Handler,
		},
		{
			MethodName: "RebootAll",
			Handler:    _Enodebd_RebootAll_Handler,
		},
		{
			MethodName: "GetStatus",
			Handler:    _Enodebd_GetStatus_Handler,
		},
		{
			MethodName: "GetAllEnodebStatus",
			Handler:    _Enodebd_GetAllEnodebStatus_Handler,
		},
		{
			MethodName: "GetEnodebStatus",
			Handler:    _Enodebd_GetEnodebStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lte/protos/enodebd.proto",
}

func init() { proto.RegisterFile("lte/protos/enodebd.proto", fileDescriptor_enodebd_02b65a7f6c4d585b) }

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

repository: tcirstea/magma

license_type: permissive

repo_name: tcirstea/magma

branch_name: refs/heads/master

gha_license_id: NOASSERTION

extension: go


text:
package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"strings"
)

var target = 19690720

func part1(prog []int, input int) int {
	program := make([]int, len(prog))
	copy(program, prog)
	ip := 0
	output := make([]int, 0)

	for {
		opcode := program[ip] % 100
		code := program[ip] / 100

		param1 := code % 10
		param2 := (code / 10) % 10
		param3 := (code / 100) % 10
		if param3 > 0 {
			log.Println("param3 in usez!")
		}
		// log.Println(ip, opcode)

		switch opcode {
		case 1:
			a, b, d := program[ip+1], program[ip+2], program[ip+3]
			// log.Println(ip, "ADD", a, b, d, param1, param2, param3)
			if param1 == 0 {
				a = program[a]
			}
			if param2 == 0 {
				b = program[b]
			}

			program[d] = a + b
			ip += 4
		case 2:
			a, b, d := program[ip+1], program[ip+2], program[ip+3]
			// log.Println(ip, "MULT", a, b, d, param1, param2, param3)
			if param1 == 0 {
				a = program[a]
			}
			if param2 == 0 {
				b = program[b]
			}
			program[d] = a * b
			ip += 4
		case 3:
			d := program[ip+1]
			// log.Println(ip, "IN", d, param1)
			program[d] = input
			ip += 2
		case 4:
			d := program[ip+1]

			if param1 == 0 {
				d = program[d]
			}

			// log.Println(ip, "OUT", d, param1)
			output = append(output, d)
			ip += 2
		case 5:
			a, d := program[ip+1], program[ip+2]
			// log.Println(ip, "JNZ", a, d, param1, param2)
			if param1 == 0 {
				a = program[a]
			}
			if param2 == 0 {
				d = program[d]
			}
			if a != 0 {
				// log.Println("t", a)
				ip = d
			} else {
				// log.Println("f")
				ip += 3
			}
		case 6:
			a, d := program[ip+1], program[ip+2]
			// log.Println(ip, "JZ", a, d, param1, param2)
			if param1 == 0 {
				a = program[a]
			}
			if param2 == 0 {
				d = program[d]
			}
			if a == 0 {
				// log.Println("t")
				ip = d
			} else {
				// log.Println("f")
				ip += 3
			}
		case 7:
			a, b, d := program[ip+1], program[ip+2], program[ip+3]
			// log.Println(ip, "CMPL", a, b, d, param1, param2)
			if param1 == 0 {
				a = program[a]
			}
			if param2 == 0 {
				b = program[b]
			}
			if a < b {
				program[d] = 1
			} else {
				program[d] = 0
			}
			ip += 4
		case 8:
			a, b, d := program[ip+1], program[ip+2], program[ip+3]
			// log.Println(ip, "CMP", a, b, d, param1, param2)
			if param1 == 0 {
				a = program[a]
			}
			if param2 == 0 {
				b = program[b]
			}
			if a == b {
				// log.Println("t")
				program[d] = 1
			} else {
				// log.Println("f")
				program[d] = 0
			}
			ip += 4
		case 99:
			log.Println("x", output)
			return program[0]
		default:
			log.Fatal("fatal", program[ip])
		}

	}

}

func parse(s string) []int {
	s1 := strings.Split(s, ",")
	o := make([]int, len(s1)*10)
	for k := range s1 {
		a, _ := strconv.Atoi(s1[k])
		o[k] = a
	}
	return o
}

func main() {
	if true {
		fmt.Println(part1(parse("1002,4,3,4,33"), 1))
		// fmt.Println(part1(parse("3,9,8,9,10,9,4,9,99,-1,8"), 5))

		test := parse("3,21,1008,21,8,20,1005,20,22,107,8,21,20,1006,20,31,1106,0,36,98,0,0,1002,21,125,20,4,20,1105,1,46,104,999,1105,1,46,1101,1000,1,20,4,20,1105,1,46,98,99")
		// fmt.Println(part1(parse(), 12, 2, []int{8}))
		fmt.Println(part1(test, 1))
		fmt.Println(part1(test, 8))
		fmt.Println(part1(test, 9))

	}
	if true {
		fileName := "input.txt"

		file, err := os.Open(fileName)
		if err != nil {
			log.Fatal(err)
		}
		defer file.Close()

		scanner := bufio.NewScanner(file)
		scanner.Scan()
		prog := parse(scanner.Text())

		fmt.Println(part1(prog, 1))
		fmt.Println(part1(prog, 5))
		// 7506531 too high

		// // noun, verb := 0, 0
		// found := make(chan int)
		// for noun := 0; noun < 100; noun++ {
		// 	for verb := 0; verb < 100; verb++ {
		// 		go func(noun, verb int) {
		// 			a := part1(prog, noun, verb)
		// 			if a == 19690720 {
		// 				found <- noun*100 + verb
		// 			}
		// 		}(noun, verb)
		// 	}
		// }
		// log.Println(<-found)
	}

}

repository: hazimhafis/adventofcode

repo_name: hazimhafis/adventofcode


text:
# Find Clang
#
# It defines the following variables
# CLANG_FOUND        - True if Clang found.
# CLANG_INCLUDE_DIRS - where to find Clang include files
# CLANG_LIBRARIES    - list of clang libs
# CLANG_CXXFLAGS     - COMPILE_FLAGS for Clang

if(NOT LLVM_INCLUDE_DIRS OR NOT LLVM_LIBRARY_DIRS)
   message(FATAL_ERROR "No LLVM and Clang support requires LLVM")
else()
  macro(FIND_AND_ADD_CLANG_LIB _libname_)
    find_library(CLANG_${_libname_}_LIB ${_libname_}
        HINTS ${LLVM_LIBRARY_DIRS}
        NO_SYSTEM_ENVIRONMENT_PATH
        NO_DEFAULT_PATH)
    if(CLANG_${_libname_}_LIB)
      set(CLANG_LIBRARIES ${CLANG_LIBRARIES} ${CLANG_${_libname_}_LIB})
    else()
      message(FATAL_ERROR "${_libname_} not found")
    endif()
  endmacro()

  # Clang shared library provides just the limited C interface, so it
  # can not be used.  We look for the static libraries.
  FIND_AND_ADD_CLANG_LIB(clangAST)
  FIND_AND_ADD_CLANG_LIB(clangAnalysis)
  FIND_AND_ADD_CLANG_LIB(clangBasic)
  FIND_AND_ADD_CLANG_LIB(clangDriver)
  FIND_AND_ADD_CLANG_LIB(clangFrontend)
  FIND_AND_ADD_CLANG_LIB(clangLex)
  FIND_AND_ADD_CLANG_LIB(clangParse)
  FIND_AND_ADD_CLANG_LIB(clangRewrite)
  FIND_AND_ADD_CLANG_LIB(clangSema)
  FIND_AND_ADD_CLANG_LIB(clangSerialization)
  FIND_AND_ADD_CLANG_LIB(clangTooling)
  FIND_AND_ADD_CLANG_LIB(clangASTMatchers)
  FIND_AND_ADD_CLANG_LIB(clangEdit)
  FIND_AND_ADD_CLANG_LIB(clangFormat)
  FIND_AND_ADD_CLANG_LIB(clangToolingCore)

  find_path(CLANG_INCLUDE_DIRS clang/Basic/Version.h HINTS "${LLVM_ROOT_DIR}/include")

  if(NOT CLANG_INCLUDE_DIRS)
    message(FATAL_ERROR "Could not find clang include directories")
  endif()

  if(NOT CLANG_LIBRARIES AND NOT CLANG_INCLUDE_DIRS AND CLANG_FIND_REQUIRED)
      message(FATAL_ERROR "Could NOT find Clang")
  endif()
endif()
find_package_handle_standard_args(Clang
    REQUIRED_VARS LLVM_ROOT_DIR LLVM_HOST_TARGET
    VERSION_VAR LLVM_VERSION_STRING)

repository: falcon-computing/DSGen

repo_name: falcon-computing/DSGen

extension: cmake


text:
@phdthesis{futrell2017memory,
 address = {Cambridge, MA},
 author = {Richard Futrell},
 school = {Massachusetts Institute of Technology},
 title = {Memory and locality in natural language},
 url = {http://socsci.uci.edu/~rfutrell/papers/futrell2017memory.pdf},
 year = {2017}
}

license: MIT

repository: langprocgroup/academic-kickstart

repo_name: langprocgroup/academic-kickstart

gha_license_id: MIT

extension: bib


text:
@article{xiao2011use,
 author = {Xiao, Xiao and White, Ethan P and Hooten, Mevin B and Durham, Susan L},
 journal = {Ecology},
 number = {10},
 pages = {1887--1894},
 publisher = {Ecological Society of America},
 title = {On the use of log-transformation vs. nonlinear regression for analyzing biological power laws},
 volume = {92},
 year = {2011}
}

repository: weecology/website

repo_name: weecology/website

branch_name: refs/heads/main

gha_language: TeX


text:
@misc{kubsch_krist_rosenberg_2022,
 title={Distributing Epistemic Functions and Tasks - A Framework for Augmenting Human Analytic Power With Machine Learning in Science Education Research},
 url={osf.io/sg9jk},
 DOI={10.31219/osf.io/sg9jk},
 publisher={OSF Preprints},
 author={Kubsch, Marcus and Krist, Christina and Rosenberg, Joshua},
 year={2022},
 month={Jan}
}


text:
require file-5.16.inc
FILESEXTRAPATHS_prepend = "${THISDIR}/files:${COREBASE}/meta/recipes-devtools/file/${BPN}:"

inherit debian-package
DEBIAN_SECTION = "utils"
DPR = "0"

LICENSE = "BSD-2-Clause"
LIC_FILES_CHKSUM = "file://COPYING;md5=975f248ba2aad6c08f97d927adf001c4"

repository: takuya-t/meta-debian

repo_name: takuya-t/meta-debian

branch_name: refs/heads/daisy

extension: bb


text:
// Copyright 2017, Square, Inc.

package cdc_test

import (
	"testing"

	"github.com/square/etre/cdc"
	"github.com/square/etre/db"
)

// @todo: make this configurable
var delayDatabase = "etre_test"
var delayCollection = "cdc"

func delaySetup(t *testing.T) db.Connector {
	// @todo: make this configurable
	conn := db.NewConnector("localhost:27017", 1, nil, nil)

	err := conn.Init()
	if err != nil {
		t.Errorf("error connecting to mongo: %s", err)
	}

	return conn
}

func delayTeardown(t *testing.T, conn db.Connector) {
	s, err := conn.Connect()
	if err != nil {
		t.Errorf("error connecting to mongo: %s", err)
	}

	err = s.DB(delayDatabase).C(delayCollection).DropCollection()
	if err != nil {
		t.Errorf("error deleting CDC events: %s", err)
	}

	// Close db connection.
	conn.Close()
}

func TestDynamicDelayer(t *testing.T) {
	conn := delaySetup(t)
	defer delayTeardown(t, conn)

	d, err := cdc.NewDynamicDelayer(conn, delayDatabase, delayCollection)
	if err != nil {
		t.Error(err)
	}

	// Start change #1.
	changeId1 := "abc"
	cdc.CurrentTimestamp = func() int64 { return 1 }
	err = d.BeginChange(changeId1)
	if err != nil {
		t.Error(err)
	}

	// Verify the max timestamp.
	maxTimestamp, err := d.MaxTimestamp()
	if err != nil {
		t.Error(err)
	}
	if maxTimestamp != 1 {
		t.Errorf("maxTimestamp = %d, expected 1", maxTimestamp)
	}

	// Start change #2.
	changeId2 := "def"
	cdc.CurrentTimestamp = func() int64 { return 3 }
	err = d.BeginChange(changeId2)
	if err != nil {
		t.Error(err)
	}

	// Verify the max timestamp hasn't changed.
	maxTimestamp, err = d.MaxTimestamp()
	if err != nil {
		t.Error(err)
	}
	if maxTimestamp != 1 {
		t.Errorf("maxTimestamp = %d, expected 1", maxTimestamp)
	}

	// Start change #3.
	changeId3 := "ghi"
	cdc.CurrentTimestamp = func() int64 { return 9 }
	err = d.BeginChange(changeId3)
	if err != nil {
		t.Error(err)
	}

	// Verify the max timestamp hasn't changed.
	maxTimestamp, err = d.MaxTimestamp()
	if err != nil {
		t.Error(err)
	}
	if maxTimestamp != 1 {
		t.Errorf("maxTimestamp = %d, expected 1", maxTimestamp)
	}

	// Stop change #1.
	err = d.EndChange(changeId1)
	if err != nil {
		t.Error(err)
	}

	// Verify the max timestamp is now change #2s start time.
	maxTimestamp, err = d.MaxTimestamp()
	if err != nil {
		t.Error(err)
	}
	if maxTimestamp != 3 {
		t.Errorf("maxTimestamp = %d, expected 3", maxTimestamp)
	}

	// Stop change #3.
	err = d.EndChange(changeId3)
	if err != nil {
		t.Error(err)
	}

	// Verify the max timestamp hasn't changed.
	maxTimestamp, err = d.MaxTimestamp()
	if err != nil {
		t.Error(err)
	}
	if maxTimestamp != 3 {
		t.Errorf("maxTimestamp = %d, expected 3", maxTimestamp)
	}

	// Stop change #2.
	err = d.EndChange(changeId2)
	if err != nil {
		t.Error(err)
	}

	// Verify the max timestamp is now the current time.
	cdc.CurrentTimestamp = func() int64 { return 50 }
	maxTimestamp, err = d.MaxTimestamp()
	if err != nil {
		t.Error(err)
	}
	if maxTimestamp != 50 {
		t.Errorf("maxTimestamp = %d, expected 50", maxTimestamp)
	}
}

func TestStaticDelayer(t *testing.T) {
	delay := 5
	d, err := cdc.NewStaticDelayer(delay)
	if err != nil {
		t.Error(err)
	}

	cdc.CurrentTimestamp = func() int64 { return 12 }
	maxTimestamp, err := d.MaxTimestamp()
	if err != nil {
		t.Error(err)
	}
	if maxTimestamp != 7 {
		t.Errorf("maxTimestamp = %d, expected 7", maxTimestamp)
	}
}

repository: forkkit/etre

repo_name: forkkit/etre


text:
@article{Page_2016,
 author = {Page, Andrew J. and Taylor, Ben and Delaney, Aidan J. and Soares, Jorge and Seemann, Torsten and Keane, Jacqueline A. and Harris, Simon R.},
 title = {{SNP}-sites: rapid efficient extraction of {SNPs} from multi-{FASTA} alignments},
 journal = {Microbial Genomics},
 publisher = {Microbiology Society},
 year = {2016},
 month = {apr},
 number = {4},
 volume = {2},
 url = {https://doi.org/10.1099%2Fmgen.0.000056},
 doi = {10.1099/mgen.0.000056}
}


text:
package entity

import "github.com/golang/protobuf/ptypes/timestamp"

type Transcript struct {
	Base
	Meeting    string
	Public     bool
	Contents   []Action
	Start      timestamp.Timestamp
	End        timestamp.Timestamp
	Archived   timestamp.Timestamp
	ArchiveURL string
}

repository: munjeli/robot-rules-of-order

repo_name: munjeli/robot-rules-of-order


text:
@PACKAGE_INIT@

include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")

foreach(component @sdl_components@)
  set(@PROJECT_NAME@_${component}_FOUND 1)
endforeach()

foreach(component ${@PROJECT_NAME@_FIND_COMPONENTS})
  if(NOT @PROJECT_NAME@_${component}_FOUND)
    set(@PROJECT_NAME@_${component}_FOUND 0)
    if(@PROJECT_NAME@_FIND_REQUIRED_${component})
      message(FATAL_ERROR "SDL2::${component} is not available.")
    endif()
  endif()
endforeach()

check_required_components(@PROJECT_NAME@)

extension: in


text:
// Copyright (c) 2019 Chen Lei <my@mysq.to>. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package log

import (
	"runtime"
)

// getRuntimeInfo returns function name, file name, file line of current call stack
// if cannot get those info from runtime, will return a default value ??? for function
// and file along with 0 for line
func getRuntimeInfo(depth int) (string, string, int) {
	pc, fn, ln, ok := runtime.Caller(depth)
	if !ok {
		fn = "???"
		ln = 0
	}
	function := "???"
	caller := runtime.FuncForPC(pc)
	if caller != nil {
		function = caller.Name()
	}
	return function, fn, ln
}

repository: mysqto/log

repo_name: mysqto/log


text:
require qt5-${PV}.inc
require ${PN}.inc

SRC_URI[md5sum] = "ce3868ac3be057ba112f4c8f6da67e94"
SRC_URI[sha256sum] = "8f41113571ace59f88e91d74e113e24f8f934f6b571da3c976b53bd42e86c238"


text:
package drone

import (
	"crypto/tls"
	"fmt"
	"net/http"

	"github.com/drone/drone-go/drone"
	"github.com/hashicorp/terraform/helper/schema"
	"github.com/jackspirou/syscerts"
	"golang.org/x/oauth2"
)

func Provider() *schema.Provider {
	return &schema.Provider{
		Schema: map[string]*schema.Schema{
			"server": {
				Type:        schema.TypeString,
				Required:    true,
				Description: "URL for the drone server",
				DefaultFunc: schema.EnvDefaultFunc("DRONE_SERVER", nil),
			},
			"token": {
				Type:        schema.TypeString,
				Required:    true,
				Description: "API Token for the drone server",
				DefaultFunc: schema.EnvDefaultFunc("DRONE_TOKEN", nil),
			},
		},
		ResourcesMap: map[string]*schema.Resource{
			"drone_repo":      resourceRepo(),
			"drone_secret":    resourceSecret(),
			"drone_orgsecret": resourceOrgSecret(),
			"drone_user":      resourceUser(),
			"drone_cron":      resourceCron(),
		},
		ConfigureFunc: providerConfigureFunc,
	}
}

func providerConfigureFunc(data *schema.ResourceData) (interface{}, error) {
	config := new(oauth2.Config)

	certs := syscerts.SystemRootsPool()
	tlsConfig := &tls.Config{
		RootCAs:            certs,
		InsecureSkipVerify: false,
	}

	auther := config.Client(
		oauth2.NoContext,
		&oauth2.Token{AccessToken: data.Get("token").(string)},
	)

	trans, _ := auther.Transport.(*oauth2.Transport)
	trans.Base = &http.Transport{
		TLSClientConfig: tlsConfig,
		Proxy:           http.ProxyFromEnvironment,
	}

	client := drone.NewClient(data.Get("server").(string), auther)

	if _, err := client.Self(); err != nil {
		return nil, fmt.Errorf("drone client failed: %s", err)
	}

	return client, nil
}

repository: Lucretius/terraform-provider-drone

repo_name: Lucretius/terraform-provider-drone

gha_language: Go


text:
# CMake generated Testfile for
# Source directory: /Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance
# Build directory: /Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance
#
# This file includes the relevant testing commands required for
# testing this directory and lists subdirectories to be tested as well.
add_test(ControlInstrInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/ControlInstrInst_unittest")
set_tests_properties(ControlInstrInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;5;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(ExportInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/ExportInst_unittest")
set_tests_properties(ExportInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;6;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(FuncInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/FuncInst_unittest")
set_tests_properties(FuncInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;7;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(GlobalInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/GlobalInst_unittest")
set_tests_properties(GlobalInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;8;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(InstrInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/InstrInst_unittest")
set_tests_properties(InstrInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;9;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(MemInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/MemInst_unittest")
set_tests_properties(MemInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;10;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(ModuleInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/ModuleInst_unittest")
set_tests_properties(ModuleInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;11;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(TableInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/TableInst_unittest")
set_tests_properties(TableInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;12;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(MemoryInstrInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/MemoryInstrInst_unittest")
set_tests_properties(MemoryInstrInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;13;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(NumericInstrInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/NumericInstrInst_unittest")
set_tests_properties(NumericInstrInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;14;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(ParametricInstrInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/ParametricInstrInst_unittest")
set_tests_properties(ParametricInstrInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;15;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")
add_test(VariableInstrInst_unittest "/Users/liqinghua/git/wasmLearning/WasmVM/cmake-build-debug/test/unittests/lib/instance/VariableInstrInst_unittest")
set_tests_properties(VariableInstrInst_unittest PROPERTIES  _BACKTRACE_TRIPLES "/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/CMakeLists.txt;34;add_test;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;2;add_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;16;add_instance_unittest;/Users/liqinghua/git/wasmLearning/WasmVM/test/unittests/lib/instance/CMakeLists.txt;0;")

gha_language: Makefile