# LearnLib

[![CI](https://github.com/LearnLib/learnlib/actions/workflows/ci.yml/badge.svg)](https://github.com/LearnLib/learnlib/actions/workflows/ci.yml)
[![Coverage](https://coveralls.io/repos/github/LearnLib/learnlib/badge.svg?branch=develop)](https://coveralls.io/github/LearnLib/learnlib?branch=develop)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/de.learnlib/learnlib-parent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/de.learnlib/learnlib-parent)

LearnLib is a free, open source ([Apache License, v2.0][1]) Java library for automata learning algorithms.

## About

LearnLib is mainly developed at [TU Dortmund University, Germany][2].
Its original purpose is to provide a framework for research on automata learning algorithms as well as for their application in practice.

The public version is a re-implemented version of the former closed-source version of LearnLib.
While certain features have been stripped for improved modularity, development has since then extended the features offered.
Currently, the following learning algorithms with respective target models are supported:

| Algorithm (active)  | Target models               |     | Algorithm (passive)   | Models                |
|---------------------|-----------------------------|-----|-----------------------|-----------------------|
| AAAR                | `DFA` `Mealy` `Moore`       |     | OSTIA                 | `SST`                 |
| ADT                 | `Mealy`                     |     | RPNI (incl. variants) | `DFA` `Mealy` `Moore` |
| DHC                 | `Mealy`                     |     |                       |                       |
| Kearns & Vazirani   | `DFA` `Mealy`               |     |                       |                       |
| L* (incl. variants) | `DFA` `Mealy` `Moore`       |     |                       |                       |
| NL*                 | `NFA`                       |     |                       |                       |
| Observation Pack    | `DFA` `Mealy` `Moore` `VPA` |     |                       |                       |
| OML                 | `DFA` `Mealy`               |     |                       |                       |
| Procedural          | `SPA` `SBA` `SPMM`          |     |                       |                       |
| TTT                 | `DFA` `Mealy` `Moore` `VPA` |     |                       |                       |

Additionally, LearnLib offers a variety of tools to ease the practical application of automata learning on real-world systems.
This includes drivers and mappers for interfacing software systems with the LearnLib API as well as caches and parallelization for improving the overall performance of the learning setup.
Also, more nuanced setups such as Black-Box-Checking (via [LTSMin][ltsmin]) or inferring partial machines are possible.

While we strive to deliver code at a high quality, please note that there exist parts of the library that still need thorough testing.
Contributions -- whether it is in the form of new features, better documentation or tests -- are welcome.

## Build Instructions

For simply using LearnLib you may use the Maven artifacts which are available in the [Maven Central repository][maven-central].
It is also possible to download a bundled [distribution artifact][maven-central-distr] if you want to use LearnLib without Maven support.
Note that LearnLib requires Java 11 (or newer) to build but still supports Java 8 at runtime.

#### Building development versions

If you intend to use development versions of LearnLib, you can either use the deployed SNAPSHOT artifacts from the continuous integration server (see [Using Development Versions](https://github.com/LearnLib/learnlib/wiki/Using-Development-Versions)), or build them yourself.
Simply clone the development branch of the repository

```
git clone -b develop --single-branch https://github.com/LearnLib/learnlib.git
```

and run a single `mvn clean install`.
This will build all the required maven artifacts and will install them in your local Maven repository so that you can reference them in other projects.

If you plan to use a development version of LearnLib in an environment where no Maven support is available, simply run `mvn clean package -Pbundles`.
The respective JARs are then available under `distribution/target/bundles`.

**Note: Development versions of LearnLib usually depend on development versions of [AutomataLib][7].**
For building development versions of AutomataLib, see the corresponding documentation on the project's README.

#### Developing LearnLib

For developing the code base of LearnLib it is suggested to use one of the major Java IDEs which come with out-of-the-box Maven support.

* For [IntelliJ IDEA][intellij]:
  1. Select `File` -> `New` -> `Project from existing sources` and select the folder containing the development checkout.
  1. Choose "Import Project from external model", select "Maven" and click `Create`.
  1. In order to have both development versions of AutomataLib and LearnLib available at once, continue to import AutomataLib as documented in the project's README, but choose `File` -> `New` -> `Module from existing sources` as the first step.

* For [Eclipse][eclipse]:
  1. **Note**: LearnLib uses annotation processing on several occasions throughout the build process.
  This is usually handled correctly by Maven.
  However, for Eclipse, you may need to manually enable annotation processing under `Preferences` -> `Maven` -> `Annotation Processing`.
  1. Select `File` -> `Import...` and select "Existing Maven Projects".
  1. Select the folder containing the development checkout as the root directory and click `Finish`.
  1. In order to have both development versions of AutomataLib and LearnLib available at once, continue to import AutomataLib as documented in the project's README.

## Documentation

* **Maven Project Site:** [latest release](http://learnlib.github.io/learnlib/maven-site/latest/) | [older versions](http://learnlib.github.io/learnlib/maven-site/)
* **API Documentation:** [latest release](http://learnlib.github.io/learnlib/maven-site/latest/apidocs/) | [older versions](http://learnlib.github.io/learnlib/maven-site/)

## Questions?

If you have any questions regarding the usage of LearnLib or if you want to discuss new and exciting ideas for future contributions, feel free to use the [Discussions](https://github.com/LearnLib/learnlib/discussions) page to get in touch with the LearnLib community.

## Maintainers

* [Markus Frohme][6] (2017 - )
* [Falk Howar][5] (2013 - )
* [Malte Isberner][4] (2013 - 2015)

[1]: http://www.apache.org/licenses/LICENSE-2.0
[2]: http://www.cs.tu-dortmund.de
[3]: http://www.learnlib.de
[4]: https://github.com/misberner
[5]: https://github.com/fhowar
[6]: https://github.com/mtf90
[7]: https://github.com/LearnLib/automatalib

[maven-central]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22de.learnlib%22
[maven-central-distr]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22de.learnlib.distribution%22
[intellij]: https://www.jetbrains.com/idea/
[eclipse]: https://www.eclipse.org/
[ltsmin]: https://ltsmin.utwente.nl/


[SCIFIO](https://scif.io/)
======

[![](https://github.com/scifio/scifio/actions/workflows/build-main.yml/badge.svg)](https://github.com/scifio/scifio/actions/workflows/build-main.yml)
[![developer chat](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://imagesc.zulipchat.com/#narrow/stream/327239-SCIFIO)

SCIFIO (SCientific Image Format Input & Output) is an extensible Java framework
for reading and writing images, particularly N-dimensional scientific images.

This core package supports parsing pixels and metadata for a collection of open
formats. Additional formats can be supported simply by downloading SCIFIO
plugins and including them in your project.

Purpose
-------

SCIFIO's primary purpose is to provide a clear convention for supporting image
input and output. By lowering the barrier for adding new image formats, all
SCIFIO-backed software will grow more versatile and powerful.

Supported formats
-----------------

The SCIFIO core includes support for:
* APNG
* AVI
* BMP
* DICOM
* EPS
* FITS
* GIF
* ICS
* JPEG
* JPEG2000
* MNG
* Micro-Manager
* NRRD
* PCX
* PGM
* QuickTime
* TIFF
* Zipped images

Additionally,
[Bio-Formats](https://www.openmicroscopy.org/site/products/bio-formats) is
[available as a SCIFIO plugin](https://github.com/scifio/scifio-bf-compat) for
supporting more than a hundred additional proprietary formats.

For users
---------

[ImageJ2](https://github.com/imagej/imagej) and
[Fiji](https://github.com/fiji/fiji) use SCIFIO for image I/O.

For developers
--------------

Several software libraries use SCIFIO for image I/O:
* SCIFIO has built-in support for opening and saving
  [ImgLib2](https://github.com/imagej/imglib) data structures
  (see the [io.scif.img](src/main/java/io/scif/img) package).
* We have [updated Bio-Formats](https://github.com/scifio/bioformats) to
  also support SCIFIO plugins, backwards compatibly with existing code.
* [ITK](https://github.com/Kitware/ITK) has an
  [ImageIO module](https://github.com/scifio/scifio-imageio)
  for reading and writing images using SCIFIO.

Developer documentation:
* See the [SCIFIO tutorials](https://github.com/scifio/scifio-tutorials) for a
  step-by-step introduction to the SCIFIO API.
* See also the
  [SCIFIO Javadocs](https://javadoc.scijava.org/SCIFIO/).

More information
----------------

For more information, see the [SCIFIO FAQ](https://github.com/scifio/scifio/wiki/FAQ)
and [SCIFIO web site](https://scif.io/).

Getting help
------------

SCIFIO uses the [Image.sc Forum](https://forum.image.sc/) for support. Start
a new topic [tagged with `scifio`](https://forum.image.sc/tag/scifio).

Contributing to SCIFIO
----------------------

SCIFIO is an open project and anyone is very welcome to submit pull requests
to the [SCIFIO repository](https://github.com/scifio/scifio).

With SCIFIO's focus on extensibility, you typically will not need to make
upstream changes to get your formats into users' hands. However, if you are
interested in submitting a pull request, that's great!
All we ask is that you check:

    mvn clean test

from the top level.

If you're adding a new feature, it would be fantastic if you
could write a unit test for it! Simply base it on JUnit
to have it run by the SCIFIO test suite.


# Auto

[![Build Status](https://github.com/google/auto/actions/workflows/ci.yml/badge.svg)](https://github.com/google/auto/actions/workflows/ci.yml)

A collection of source code generators for [Java][java].

## Overview

[Java][java] is full of code that is mechanical, repetitive, typically untested
and sometimes the source of subtle bugs. _Sounds like a job for robots!_

The Auto subprojects are a collection of code generators that automate those
types of tasks. They create the code you would have written, but without
the bugs.

Save time.  Save code.  Save sanity.

## Subprojects

  * [AutoFactory] - JSR-330-compatible factories

    [![Maven Central](https://img.shields.io/maven-central/v/com.google.auto.factory/auto-factory.svg)](https://mvnrepository.com/artifact/com.google.auto.factory/auto-factory)

  * [AutoService] - Provider-configuration files for [`ServiceLoader`]

    [![Maven Central](https://img.shields.io/maven-central/v/com.google.auto.service/auto-service.svg)](https://mvnrepository.com/artifact/com.google.auto.service/auto-service)

  * [AutoValue] - Immutable [value-type] code generation for Java 7+.

    [![Maven Central](https://img.shields.io/maven-central/v/com.google.auto.value/auto-value.svg)](https://mvnrepository.com/artifact/com.google.auto.value/auto-value)

  * [Common] - Helper utilities for writing annotation processors.

    [![Maven Central](https://img.shields.io/maven-central/v/com.google.auto/auto-common.svg)](https://mvnrepository.com/artifact/com.google.auto/auto-common)

## License

    Copyright 2013 Google LLC

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

[AutoFactory]: https://github.com/google/auto/tree/main/factory
[AutoService]: https://github.com/google/auto/tree/main/service
[AutoValue]: https://github.com/google/auto/tree/main/value
[Common]: https://github.com/google/auto/tree/main/common

[java]: https://en.wikipedia.org/wiki/Java_(programming_language)
[value-type]: http://en.wikipedia.org/wiki/Value_object
[`ServiceLoader`]: http://docs.oracle.com/javase/7/docs/api/java/util/ServiceLoader.html


= Spring Data Couchbase image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-couchbase%2Fmain&subject=Build[link=https://jenkins.spring.io/view/SpringData/job/spring-data-couchbase/] https://gitter.im/spring-projects/spring-data[image:https://badges.gitter.im/spring-projects/spring-data.svg[Gitter]] image:https://img.shields.io/badge/Revved%20up%20by-Develocity-06A0CE?logo=Gradle&labelColor=02303A["Revved up by Develocity", link="https://ge.spring.io/scans?search.rootProjectNames=Spring Data Couchbase"]

The primary goal of the https://www.springsource.org/spring-data[Spring Data] project is to make it easier to build
Spring-powered applications that use new data access technologies such as non-relational databases, map-reduce
frameworks, and cloud based data services.

The Spring Data Couchbase project aims to provide a familiar and consistent Spring-based programming model for Couchbase
Server as a document database and cache while retaining store-specific features and capabilities. Key functional areas
of Spring Data Couchbase are a POJO centric model for interacting with a Couchbase Server Bucket and easily writing a
repository style data access layer.

Integration tests require a couchbase server with a bucket name "protected" with "password" as the password set.
If the server allows users, then an user with username "protected" with "password" as the password should also be set.
The recommended way to run tests is to install docker and use container in server.properties.

This project is lead and maintained by Couchbase, Inc.

== Features

* Spring configuration support using Java based `@Configuration` classes or an XML namespace for the Couchbase driver (Java SDK version 2.x).
* `CouchbaseTemplate` helper class that increases productivity performing common Couchbase operations. Includes integrated object mapping between documents and POJOs.
* Exception translation into Spring’s portable Data Access Exception hierarchy.
* Feature Rich Object Mapping integrated with Spring’s Conversion Service.
* Annotation based mapping metadata but extensible to support other metadata formats.
* Automatic implementation of `Repository` interfaces including support for custom finder methods (backed by Couchbase’s query language, `N1QL`) and `PagingAndSortingRepository`.
* For Couchbase server versions < 4.0, repositories can still be backed by Couchbase Views.
* Support for geospatial and multidimensional querying (backed by Couchbase Spatial Views)
* JMX administration and monitoring
* Can serve as the backend for `@Cacheable` support, to cache any objects you need for high performance access (see sibling Spring Cache project in Couchbase’s github, https://github.com/couchbaselabs/couchbase-spring-cache[couchbaselabs/couchbase-spring-cache]).

== Version compatibility

`Spring-Data Couchbase` is the Spring Data connector for the `Couchbase Java SDK 2.x` generation.

Both the SDK and this Spring Data community project are major version changes with lots of differences from their respective previous versions.

Notably, this version is compatible with `Couchbase Server 4.0`, bringing support for the `N1QL` query language.

== Code of Conduct

This project is governed by the https://github.com/spring-projects/.github/blob/e3cc2ff230d8f1dca06535aa6b5a4a23815861d4/CODE_OF_CONDUCT.md[Spring Code of Conduct].By participating, you are expected to uphold this code of conduct.Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.

== Getting Started

Here is a quick teaser of an application using Spring Data Repositories in Java:

[source,java]
----
public interface PersonRepository extends CrudRepository<Person, Long> {

  List<Person> findByLastname(String lastname);

  List<Person> findByFirstnameLike(String firstname);
}

@Service
public class MyService {

  private final PersonRepository repository;

  public MyService(PersonRepository repository) {
    this.repository = repository;
  }

  public void doWork() {

    repository.deleteAll();

    Person person = new Person();
    person.setFirstname("Couch");
    person.setLastname("Base");
    repository.save(person);

    List<Person> lastNameResults = repository.findByLastname("Base");
    List<Person> firstNameResults = repository.findByFirstnameLike("Cou*");
 }
}

@Configuration
@EnableCouchbaseRepositories
public class Config extends AbstractCouchbaseConfiguration {

	@Override
	protected List<String> getBootstrapHosts() {
		return Arrays.asList("host1", "host2");
	}

	@Override
	protected String getBucketName() {
		return "default";
	}

	@Override
	protected String getPassword() {
		return "";
	}
}
----

=== Maven configuration

Add the Maven dependency:

[source,xml]
----
<dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-couchbase</artifactId>
  <version>${version}</version>
</dependency>
----

If you'd rather like the latest snapshots of the upcoming major version, use our Maven snapshot repository and declare the appropriate dependency version.

[source,xml]
----
<dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-couchbase</artifactId>
  <version>${version}-SNAPSHOT</version>
</dependency>

<repository>
  <id>spring-snapshot</id>
  <name>Spring Snapshot Repository</name>
  <url>https://repo.spring.io/snapshot</url>
</repository>
----

== Getting Help

Having trouble with Spring Data? We’d love to help!

* Check the
https://docs.spring.io/spring-data/couchbase/docs/current/reference/html/[reference documentation], and https://docs.spring.io/spring-data/couchbase/docs/current/api/[Javadocs].
* Learn the Spring basics – Spring Data builds on Spring Framework, check the https://spring.io[spring.io] web-site for a wealth of reference documentation.
If you are just starting out with Spring, try one of the https://spring.io/guides[guides].
* Ask a question - we monitor https://stackoverflow.com[stackoverflow.com] for questions tagged with https://stackoverflow.com/tags/spring-data[`spring-data-couchbase`].
You can also chat with the community on https://gitter.im/spring-projects/spring-data[Gitter].
* Report bugs with Spring Data Couchbase at https://jira.spring.io/browse/DATACOUCH[jira.spring.io/browse/DATACOUCH].

== Reporting Issues

Spring Data uses GitHub as issue tracking system to record bugs and feature requests.
If you want to raise an issue, please follow the recommendations below:

* Before you log a bug, please search the
https://github.com/spring-projects/spring-data-couchbase/issues[issue tracker] to see if someone has already reported the problem.
* If the issue does not already exist, https://github.com/spring-projects/spring-data-couchbase/issues/new[create a new issue].
* Please provide as much information as possible with the issue report, we like to know the version of Spring Data that you are using and JVM version.
* If you need to paste code, or include a stack trace use Markdown +++```+++ escapes before and after your text.
* If possible try to create a test-case or project that replicates the issue.
Attach a link to your code or a compressed file containing your code.

== Building from Source

You don’t need to build from source to use Spring Data (binaries in https://repo.spring.io[repo.spring.io]), but if you want to try out the latest and greatest, Spring Data can be easily built with the https://github.com/takari/maven-wrapper[maven wrapper].
You also need JDK 17 or above.

[source,bash]
----
 $ ./mvnw clean install
----

If you want to build with the regular `mvn` command, you will need https://maven.apache.org/run-maven/index.html[Maven v3.5.0 or above].

_Also see link:CONTRIBUTING.adoc[CONTRIBUTING.adoc] if you wish to submit pull requests, and in particular please sign the https://cla.pivotal.io/sign/spring[Contributor’s Agreement] before your first non-trivial change._

=== Building reference documentation

Building the documentation builds also the project without running tests.

[source,bash]
----
 $ ./mvnw clean install -Pantora
----

The generated documentation is available from `target/antora/site/index.html`.

=== Building and staging reference documentation for review

[source,bash]
----
  export MY_GIT_USER=<github-user>
  mvn generate-resources
  docs=`pwd`/target/site/reference/html
  pushd /tmp
  mkdir $$
  cd $$
  # see https://docs.github.com/en/pages/getting-started-with-github-pages/creating-a-github-pages-site
  # this examples uses a repository named "staged"
  git clone git@github.com:${MY_GIT_USER}/staged.git -b gh-pages
  cd staged
  cp -R $docs/* .
  git add .
  git commit --message "stage for review"
  git push origin gh-pages
  popd
----

The generated documentation is available from `target/site/reference/html/index.html`.

== Examples

* https://github.com/spring-projects/spring-data-examples/[Spring Data Examples] contains example projects that explain specific features in more detail.

== License

Spring Data Couchbase is Open Source software released under the https://www.apache.org/licenses/LICENSE-2.0.html[Apache 2.0 license].


# The Bouncy Castle Crypto Package For Java

[![Build Status](https://travis-ci.org/bcgit/bc-java.svg?branch=master)](https://travis-ci.org/bcgit/bc-java)

The Bouncy Castle Crypto package is a Java implementation of cryptographic algorithms, it was developed by the Legion of the Bouncy Castle, a registered Australian Charity, with a little help! The Legion, and the latest goings on with this package, can be found at [https://www.bouncycastle.org](https://www.bouncycastle.org).

The Legion also gratefully acknowledges the contributions made to this package by others (see [here](https://www.bouncycastle.org/contributors.html) for the current list). If you would like to contribute to our efforts please feel free to get in touch with us or visit our [donations page](https://www.bouncycastle.org/donate), sponsor some specific work, or purchase a support contract through [Crypto Workshop](https://www.keyfactor.com/platform/bouncy-castle-support/) (now part of Keyfactor).

The package is organised so that it contains a light-weight API suitable for use in any environment (including the newly released J2ME) with the additional infrastructure to conform the algorithms to the JCE framework.

Except where otherwise stated, this software is distributed under a license based on the MIT X Consortium license. To view the license, [see here](https://www.bouncycastle.org/licence.html). The OpenPGP library also includes a modified BZIP2 library which is licensed under the [Apache Software License, Version 2.0](https://www.apache.org/licenses/).

**Note**: this source tree is not the FIPS version of the APIs - if you are interested in our FIPS version please contact us directly at  [office@bouncycastle.org](mailto:office@bouncycastle.org).

## Environmental Variables

Before invoking gradlew you need to ensure the following environmental variables are defined and point
to valid JAVA_HOMEs for each JVM version:

```
export BC_JDK8=/path/to/java8
export BC_JDK11=/path/to/java11
export BC_JDK17=/path/to/java17
export BC_JDK21=/path/to/java21
```

## Building

The project now uses ```gradlew``` which can be invoked for example:

```
# from the root of the project

# Ensure JAVA_HOME points to JDK 17 or higher JAVA_HOME

./gradlew clean build

```

The gradle script will endeavour to verify their existence but not the correctness of their value.

## Multi-release jars and testing
Some subprojects produce multi-release jars and these jars are tested in different jvm versions.
Default testing on these projects is done on java 1.8 and there are specific test tasks for other versions.

1. test11 test on java 11 JVM
2. test17 test on java 17 JVM
3. test21 test on java 21 JVM

To run all of them:

```
./gradlew clean build test11 test17 test21
```

## Code Organisation

The clean room JCE, for use with JDK 1.1 to JDK 1.3 is in the jce/src/main/java directory. From JDK 1.4 and later the JCE ships with the JVM, the source for later JDKs follows the progress that was made in the later versions of the JCE. If you are using a later version of the JDK which comes with a JCE install please **do not** include the jce directory as a source file as it will clash with the JCE API installed with your JDK.

The **core** module provides all the functionality in the ligthweight APIs.

The **prov** module provides all the JCA/JCE provider functionality.

The **util** module is the home for code which is used by other modules that does not need to be in prov. At the moment this is largely ASN.1 classes for the PKIX module.

The **pkix** module is the home for code for X.509 certificate generation and the APIs for standards that rely on ASN.1 such
as CMS, TSP, PKCS#12, OCSP, CRMF, and CMP.

The **mail** module provides an S/MIME API built on top of CMS.

The **pg** module is the home for code used to support OpenPGP.

The **tls** module is the home for code used to a general TLS API and JSSE Provider.

The build scripts that come with the full distribution allow creation of the different releases by using the different source trees while excluding classes that are not appropriate and copying in the required compatibility classes from the directories containing compatibility classes appropriate for the distribution.

If you want to try create a build for yourself, using your own environment, the best way to do it is to start with the build for the distribution you are interested in, make sure that builds, and then modify your build scripts to do the required exclusions and file copies for your setup, otherwise you are likely to get class not found exceptions. The final caveat to this is that as the j2me distribution includes some compatibility classes starting in the java package, you need to use an obfuscator to change the package names before attempting to import a midlet using the BC API.

**Important**: You will also need to check out the [bc-test-data](https://github.com/bcgit/bc-test-data) repository at the same level as the bc-java repository if you want to run the tests.

## Examples and Tests

To view some examples, look at the test programs in the packages:

*   **org.bouncycastle.crypto.test**

*   **org.bouncycastle.jce.provider.test**

*   **org.bouncycastle.cms.test**

*   **org.bouncycastle.mail.smime.test**

*   **org.bouncycastle.openpgp.test**

*   **org.bouncycastle.tsp.test**

There are also some specific example programs for dealing with SMIME and OpenPGP. They can be found in:

*   **org.bouncycastle.mail.smime.examples**

*   **org.bouncycastle.openpgp.examples**

## Mailing Lists

For those who are interested, there are 2 mailing lists for participation in this project. To subscribe use the links below and include the word subscribe in the message body. (To unsubscribe, replace **subscribe** with **unsubscribe** in the message body)

*   [announce-crypto-request@bouncycastle.org](mailto:announce-crypto-request@bouncycastle.org)
    This mailing list is for new release announcements only, general subscribers cannot post to it.
*   [dev-crypto-request@bouncycastle.org](mailto:dev-crypto-request@bouncycastle.org)
    This mailing list is for discussion of development of the package. This includes bugs, comments, requests for enhancements, questions about use or operation.

**NOTE:** You need to be subscribed to send mail to the above mailing list.

## Feedback and Contributions

If you want to provide feedback directly to the members of **The Legion** then please use [feedback-crypto@bouncycastle.org](mailto:feedback-crypto@bouncycastle.org), if you want to help this project survive please consider [donating](https://www.bouncycastle.org/donate).

For bug reporting/requests you can report issues here on github, or via feedback-crypto if required. We will accept pull requests based on this repository as well, but only on the basis that any code included may be distributed under the [Bouncy Castle License](https://www.bouncycastle.org/licence.html).

## Finally

Enjoy!