Build:
- 0
2026-03-02 19:23.53: New job: test regenerate.0.2 with dune.3.22.0~alpha0, using opam dev
from https://github.com/ocaml/opam-repository.git#refs/pull/29497/head (118a690db616b1df5c53d5fa00eb70791a80ae2c)
on debian-13-ocaml-4.14/amd64
To reproduce locally:
cd $(mktemp -d)
git clone --recursive "https://github.com/ocaml/opam-repository.git" && cd "opam-repository" && git fetch origin "refs/pull/29497/head" && git reset --hard 118a690d
git fetch origin master
git merge --no-edit a7b8d1036328cf727af175b657f3d2b732b4d868
cat > ../Dockerfile <<'END-OF-DOCKERFILE'
FROM ocaml/opam:debian-13-ocaml-4.14@sha256:ae45d5e5a934874dc44b0d004f6b8a813fba3f355216f78a39ed4f25a53e478a
USER 1000:1000
WORKDIR /home/opam
RUN sudo ln -f /usr/bin/opam-dev /usr/bin/opam
RUN opam init --reinit -ni
RUN opam option solver=builtin-0install && opam config report
ENV OPAMDOWNLOADJOBS="1"
ENV OPAMERRLOGLEN="0"
ENV OPAMPRECISETRACKING="1"
ENV CI="true"
ENV OPAM_REPO_CI="true"
RUN rm -rf opam-repository/
COPY --chown=1000:1000 . opam-repository/
RUN opam repository set-url --strict default opam-repository/
RUN opam update --depexts || true
RUN opam pin add -k version -yn dune.3.22.0~alpha0 3.22.0~alpha0
RUN opam reinstall dune.3.22.0~alpha0; \
res=$?; \
test "$res" != 31 && exit "$res"; \
export OPAMCLI=2.0; \
build_dir=$(opam var prefix)/.opam-switch/build; \
failed=$(ls "$build_dir"); \
partial_fails=""; \
for pkg in $failed; do \
if opam show -f x-ci-accept-failures: "$pkg" | grep -qF "\"debian-13\""; then \
echo "A package failed and has been disabled for CI using the 'x-ci-accept-failures' field."; \
fi; \
test "$pkg" != 'dune.3.22.0~alpha0' && partial_fails="$partial_fails $pkg"; \
done; \
test "${partial_fails}" != "" && echo "opam-repo-ci detected dependencies failing: ${partial_fails}"; \
exit 1
RUN opam reinstall regenerate.0.2; \
res=$?; \
test "$res" != 31 && exit "$res"; \
export OPAMCLI=2.0; \
build_dir=$(opam var prefix)/.opam-switch/build; \
failed=$(ls "$build_dir"); \
partial_fails=""; \
for pkg in $failed; do \
if opam show -f x-ci-accept-failures: "$pkg" | grep -qF "\"debian-13\""; then \
echo "A package failed and has been disabled for CI using the 'x-ci-accept-failures' field."; \
fi; \
test "$pkg" != 'regenerate.0.2' && partial_fails="$partial_fails $pkg"; \
done; \
test "${partial_fails}" != "" && echo "opam-repo-ci detected dependencies failing: ${partial_fails}"; \
exit 1
RUN (opam reinstall --with-test regenerate.0.2) || true
RUN opam reinstall --with-test --verbose regenerate.0.2; \
res=$?; \
test "$res" != 31 && exit "$res"; \
export OPAMCLI=2.0; \
build_dir=$(opam var prefix)/.opam-switch/build; \
failed=$(ls "$build_dir"); \
partial_fails=""; \
for pkg in $failed; do \
if opam show -f x-ci-accept-failures: "$pkg" | grep -qF "\"debian-13\""; then \
echo "A package failed and has been disabled for CI using the 'x-ci-accept-failures' field."; \
fi; \
test "$pkg" != 'regenerate.0.2' && partial_fails="$partial_fails $pkg"; \
done; \
test "${partial_fails}" != "" && echo "opam-repo-ci detected dependencies failing: ${partial_fails}"; \
exit 1
END-OF-DOCKERFILE
docker build -f ../Dockerfile .
2026-03-02 19:23.53: Using cache hint "ocaml/opam:debian-13-ocaml-4.14@sha256:ae45d5e5a934874dc44b0d004f6b8a813fba3f355216f78a39ed4f25a53e478a-dune.3.22.0~alpha0-regenerate.0.2-118a690db616b1df5c53d5fa00eb70791a80ae2c"
2026-03-02 19:23.53: Using OBuilder spec:
((from ocaml/opam:debian-13-ocaml-4.14@sha256:ae45d5e5a934874dc44b0d004f6b8a813fba3f355216f78a39ed4f25a53e478a)
(user (uid 1000) (gid 1000))
(workdir /home/opam)
(run (shell "sudo ln -f /usr/bin/opam-dev /usr/bin/opam"))
(run (network host)
(shell "opam init --reinit --config .opamrc-sandbox -ni"))
(run (shell "opam option solver=builtin-0install && opam config report"))
(env OPAMDOWNLOADJOBS 1)
(env OPAMERRLOGLEN 0)
(env OPAMPRECISETRACKING 1)
(env CI true)
(env OPAM_REPO_CI true)
(run (shell "rm -rf opam-repository/"))
(copy (src .) (dst opam-repository/))
(run (shell "opam repository set-url --strict default opam-repository/"))
(run (network host)
(shell "opam update --depexts || true"))
(run (shell "opam pin add -k version -yn dune.3.22.0~alpha0 3.22.0~alpha0"))
(run (cache (opam-archives (target /home/opam/.opam/download-cache)))
(network host)
(shell "opam reinstall dune.3.22.0~alpha0;\
\n res=$?;\
\n test \"$res\" != 31 && exit \"$res\";\
\n export OPAMCLI=2.0;\
\n build_dir=$(opam var prefix)/.opam-switch/build;\
\n failed=$(ls \"$build_dir\");\
\n partial_fails=\"\";\
\n for pkg in $failed; do\
\n if opam show -f x-ci-accept-failures: \"$pkg\" | grep -qF \"\\\"debian-13\\\"\"; then\
\n echo \"A package failed and has been disabled for CI using the 'x-ci-accept-failures' field.\";\
\n fi;\
\n test \"$pkg\" != 'dune.3.22.0~alpha0' && partial_fails=\"$partial_fails $pkg\";\
\n done;\
\n test \"${partial_fails}\" != \"\" && echo \"opam-repo-ci detected dependencies failing: ${partial_fails}\";\
\n exit 1"))
(run (cache (opam-archives (target /home/opam/.opam/download-cache)))
(network host)
(shell "opam reinstall regenerate.0.2;\
\n res=$?;\
\n test \"$res\" != 31 && exit \"$res\";\
\n export OPAMCLI=2.0;\
\n build_dir=$(opam var prefix)/.opam-switch/build;\
\n failed=$(ls \"$build_dir\");\
\n partial_fails=\"\";\
\n for pkg in $failed; do\
\n if opam show -f x-ci-accept-failures: \"$pkg\" | grep -qF \"\\\"debian-13\\\"\"; then\
\n echo \"A package failed and has been disabled for CI using the 'x-ci-accept-failures' field.\";\
\n fi;\
\n test \"$pkg\" != 'regenerate.0.2' && partial_fails=\"$partial_fails $pkg\";\
\n done;\
\n test \"${partial_fails}\" != \"\" && echo \"opam-repo-ci detected dependencies failing: ${partial_fails}\";\
\n exit 1"))
(run (network host)
(shell "(opam reinstall --with-test regenerate.0.2) || true"))
(run (shell "opam reinstall --with-test --verbose regenerate.0.2;\
\n res=$?;\
\n test \"$res\" != 31 && exit \"$res\";\
\n export OPAMCLI=2.0;\
\n build_dir=$(opam var prefix)/.opam-switch/build;\
\n failed=$(ls \"$build_dir\");\
\n partial_fails=\"\";\
\n for pkg in $failed; do\
\n if opam show -f x-ci-accept-failures: \"$pkg\" | grep -qF \"\\\"debian-13\\\"\"; then\
\n echo \"A package failed and has been disabled for CI using the 'x-ci-accept-failures' field.\";\
\n fi;\
\n test \"$pkg\" != 'regenerate.0.2' && partial_fails=\"$partial_fails $pkg\";\
\n done;\
\n test \"${partial_fails}\" != \"\" && echo \"opam-repo-ci detected dependencies failing: ${partial_fails}\";\
\n exit 1"))
)
2026-03-02 19:23.53: Waiting for resource in pool OCluster
2026-03-03 04:10.13: Waiting for worker…
2026-03-03 04:12.56: Got resource from pool OCluster
Building on toxis.caelum.ci.dev
All commits already cached
Updating files: 89% (16520/18363)
Updating files: 90% (16527/18363)
Updating files: 91% (16711/18363)
Updating files: 92% (16894/18363)
Updating files: 93% (17078/18363)
Updating files: 94% (17262/18363)
Updating files: 95% (17445/18363)
Updating files: 96% (17629/18363)
Updating files: 97% (17813/18363)
Updating files: 98% (17996/18363)
Updating files: 99% (18180/18363)
Updating files: 100% (18363/18363)
Updating files: 100% (18363/18363), done.
HEAD is now at a7b8d10363 Merge pull request #29489 from anuragsoni/opam-publish-kqueue.0.7.0
Updating a7b8d10363..118a690db6
Fast-forward
.../chrome-trace/chrome-trace.3.22.0~alpha0/opam | 39 +++++++++++
.../dune-action-plugin.3.22.0~alpha0/opam | 52 +++++++++++++++
.../dune-action-trace.3.22.0~alpha0/opam | 40 ++++++++++++
.../dune-build-info.3.22.0~alpha0/opam | 45 +++++++++++++
.../dune-configurator.3.22.0~alpha0/opam | 49 ++++++++++++++
packages/dune-glob/dune-glob.3.22.0~alpha0/opam | 42 ++++++++++++
.../dune-private-libs.3.22.0~alpha0/opam | 50 +++++++++++++++
.../dune-rpc-lwt/dune-rpc-lwt.3.22.0~alpha0/opam | 41 ++++++++++++
packages/dune-rpc/dune-rpc.3.22.0~alpha0/opam | 44 +++++++++++++
packages/dune-site/dune-site.3.22.0~alpha0/opam | 37 +++++++++++
packages/dune/dune.3.22.0~alpha0/opam | 75 ++++++++++++++++++++++
packages/dyn/dyn.3.22.0~alpha0/opam | 40 ++++++++++++
packages/fs-io/fs-io.3.22.0~alpha0/opam | 39 +++++++++++
packages/ocamlc-loc/ocamlc-loc.3.22.0~alpha0/opam | 43 +++++++++++++
packages/ordering/ordering.3.22.0~alpha0/opam | 38 +++++++++++
packages/stdune/stdune.3.22.0~alpha0/opam | 46 +++++++++++++
.../top-closure/top-closure.3.22.0~alpha0/opam | 38 +++++++++++
packages/xdg/xdg.3.22.0~alpha0/opam | 39 +++++++++++
18 files changed, 797 insertions(+)
create mode 100644 packages/chrome-trace/chrome-trace.3.22.0~alpha0/opam
create mode 100644 packages/dune-action-plugin/dune-action-plugin.3.22.0~alpha0/opam
create mode 100644 packages/dune-action-trace/dune-action-trace.3.22.0~alpha0/opam
create mode 100644 packages/dune-build-info/dune-build-info.3.22.0~alpha0/opam
create mode 100644 packages/dune-configurator/dune-configurator.3.22.0~alpha0/opam
create mode 100644 packages/dune-glob/dune-glob.3.22.0~alpha0/opam
create mode 100644 packages/dune-private-libs/dune-private-libs.3.22.0~alpha0/opam
create mode 100644 packages/dune-rpc-lwt/dune-rpc-lwt.3.22.0~alpha0/opam
create mode 100644 packages/dune-rpc/dune-rpc.3.22.0~alpha0/opam
create mode 100644 packages/dune-site/dune-site.3.22.0~alpha0/opam
create mode 100644 packages/dune/dune.3.22.0~alpha0/opam
create mode 100644 packages/dyn/dyn.3.22.0~alpha0/opam
create mode 100644 packages/fs-io/fs-io.3.22.0~alpha0/opam
create mode 100644 packages/ocamlc-loc/ocamlc-loc.3.22.0~alpha0/opam
create mode 100644 packages/ordering/ordering.3.22.0~alpha0/opam
create mode 100644 packages/stdune/stdune.3.22.0~alpha0/opam
create mode 100644 packages/top-closure/top-closure.3.22.0~alpha0/opam
create mode 100644 packages/xdg/xdg.3.22.0~alpha0/opam
(from ocaml/opam:debian-13-ocaml-4.14@sha256:ae45d5e5a934874dc44b0d004f6b8a813fba3f355216f78a39ed4f25a53e478a)
2026-03-03 04:12.59 ---> using "40de8e47c13dd397f7466181b47c70cd31f6d05f624f7f51643a7089a29a5322" from cache
/: (user (uid 1000) (gid 1000))
/: (workdir /home/opam)
/home/opam: (run (shell "sudo ln -f /usr/bin/opam-dev /usr/bin/opam"))
2026-03-03 04:12.59 ---> using "11e955cadb21ab08a7e8407d7e49d7e8b8232723aa9e80323bab6a7d993e9a38" from cache
/home/opam: (run (network host)
(shell "opam init --reinit --config .opamrc-sandbox -ni"))
This version of opam requires an update to the layout of /home/opam/.opam from version 2.0 to version 2.2, which can't be reverted.
You may want to back it up before going further.
Configuring from /home/opam/.opamrc-sandbox, then /home/opam/.opamrc, and finally from built-in defaults.
Checking for available remotes: rsync and local, git.
- you won't be able to use mercurial repositories unless you install the hg command on your system.
- you won't be able to use darcs repositories unless you install the darcs command on your system.
Continue? [Y/n] y
Format upgrade done.
<><> Updating repositories ><><><><><><><><><><><><><><><><><><><><><><><><><><>
[default] Initialised
2026-03-03 04:12.59 ---> using "b84411f14b612833c97eea3b0fb49d7afb0294cf8c4774caaff1f8b0f1bd5849" from cache
/home/opam: (run (shell "opam option solver=builtin-0install && opam config report"))
Set to 'builtin-0install' the field solver in global configuration
# opam config report
# opam-version 2.5.0
# self-upgrade no
# system arch=x86_64 os=linux os-distribution=debian os-version=13
# solver builtin-0install
# install-criteria -changed,-count[avoid-version,solution]
# upgrade-criteria -count[avoid-version,solution]
# jobs 71
# repositories 1 (version-controlled)
# pinned 1 (version)
# current-switch 4.14
# invariant ["ocaml-base-compiler" {= "4.14.2"}]
# compiler-packages ocaml-base-compiler.4.14.2, ocaml-options-vanilla.1
# ocaml:native true
# ocaml:native-tools true
# ocaml:native-dynlink true
# ocaml:stubsdir /home/opam/.opam/4.14/lib/ocaml/stublibs:/home/opam/.opam/4.14/lib/ocaml
# ocaml:preinstalled false
# ocaml:compiler 4.14.2
2026-03-03 04:12.59 ---> using "bc1392749f7c1b1568053e91f3061e53f54f3bf6892fcf3fa14761d0f2fabccc" from cache
/home/opam: (env OPAMDOWNLOADJOBS 1)
/home/opam: (env OPAMERRLOGLEN 0)
/home/opam: (env OPAMPRECISETRACKING 1)
/home/opam: (env CI true)
/home/opam: (env OPAM_REPO_CI true)
/home/opam: (run (shell "rm -rf opam-repository/"))
2026-03-03 04:12.59 ---> using "0f88aad717079fee185cb5f7b0853d5dede0158dafac18dc05292641ad1318aa" from cache
/home/opam: (copy (src .) (dst opam-repository/))
2026-03-03 04:13.01 ---> using "cf2f29575da4e00ad2c0e3200eaf5375ace45ec778f515d81ffd2e5eb96c41f1" from cache
/home/opam: (run (shell "opam repository set-url --strict default opam-repository/"))
[default] Initialised
2026-03-03 04:13.01 ---> using "c517023779902244dbe5c8fbf440d1dd4569daf367c1e2ee7dd7eb370c41d91c" from cache
/home/opam: (run (network host)
(shell "opam update --depexts || true"))
+ /usr/bin/sudo "apt-get" "update"
- Hit:1 http://deb.debian.org/debian trixie InRelease
- Get:2 http://deb.debian.org/debian trixie-updates InRelease [47.3 kB]
- Get:3 http://deb.debian.org/debian-security trixie-security InRelease [43.4 kB]
- Get:4 http://deb.debian.org/debian-security trixie-security/main amd64 Packages [113 kB]
- Fetched 203 kB in 0s (1668 kB/s)
- Reading package lists...
-
2026-03-03 04:13.01 ---> using "a2e6599fe15f34bfd0a71de19dbfccfacdc1f910f7a37fea793bb8ff67d4ba47" from cache
/home/opam: (run (shell "opam pin add -k version -yn dune.3.22.0~alpha0 3.22.0~alpha0"))
dune is now pinned to version 3.22.0~alpha0
2026-03-03 04:13.01 ---> using "9ecf7f496eb9b328aa3c8f7333a40a30e123b33b9d8b5606b7ac6bfc2b62fac7" from cache
/home/opam: (run (cache (opam-archives (target /home/opam/.opam/download-cache)))
(network host)
(shell "opam reinstall dune.3.22.0~alpha0;\
\n res=$?;\
\n test \"$res\" != 31 && exit \"$res\";\
\n export OPAMCLI=2.0;\
\n build_dir=$(opam var prefix)/.opam-switch/build;\
\n failed=$(ls \"$build_dir\");\
\n partial_fails=\"\";\
\n for pkg in $failed; do\
\n if opam show -f x-ci-accept-failures: \"$pkg\" | grep -qF \"\\\"debian-13\\\"\"; then\
\n echo \"A package failed and has been disabled for CI using the 'x-ci-accept-failures' field.\";\
\n fi;\
\n test \"$pkg\" != 'dune.3.22.0~alpha0' && partial_fails=\"$partial_fails $pkg\";\
\n done;\
\n test \"${partial_fails}\" != \"\" && echo \"opam-repo-ci detected dependencies failing: ${partial_fails}\";\
\n exit 1"))
dune.3.22.0~alpha0 is not installed. Install it? [Y/n] y
The following actions will be performed:
=== install 1 package
- install dune 3.22.0~alpha0 (pinned)
<><> Processing actions <><><><><><><><><><><><><><><><><><><><><><><><><><><><>
-> retrieved dune.3.22.0~alpha0 (cached)
-> installed dune.3.22.0~alpha0
Done.
# To update the current shell environment, run: eval $(opam env)
2026-03-03 04:13.01 ---> using "1d093925996c7908c33a8109d0c1a7be5172d79d6a00aabc511d552ee2499f33" from cache
/home/opam: (run (cache (opam-archives (target /home/opam/.opam/download-cache)))
(network host)
(shell "opam reinstall regenerate.0.2;\
\n res=$?;\
\n test \"$res\" != 31 && exit \"$res\";\
\n export OPAMCLI=2.0;\
\n build_dir=$(opam var prefix)/.opam-switch/build;\
\n failed=$(ls \"$build_dir\");\
\n partial_fails=\"\";\
\n for pkg in $failed; do\
\n if opam show -f x-ci-accept-failures: \"$pkg\" | grep -qF \"\\\"debian-13\\\"\"; then\
\n echo \"A package failed and has been disabled for CI using the 'x-ci-accept-failures' field.\";\
\n fi;\
\n test \"$pkg\" != 'regenerate.0.2' && partial_fails=\"$partial_fails $pkg\";\
\n done;\
\n test \"${partial_fails}\" != \"\" && echo \"opam-repo-ci detected dependencies failing: ${partial_fails}\";\
\n exit 1"))
regenerate.0.2 is not installed. Install it? [Y/n] y
The following actions will be performed:
=== install 18 packages
- install cmdliner 1.3.0 [required by regenerate]
- install containers 2.8.1 [required by regenerate]
- install csexp 1.5.2 [required by dune-configurator]
- install dune-configurator 3.22.0~alpha0 [required by containers]
- install fmt 0.11.0 [required by regenerate]
- install iter 1.9 [required by regenerate]
- install mtime 1.4.0 [required by regenerate]
- install ocamlbuild 0.16.1 [required by fmt, mtime]
- install ocamlfind 1.9.8 [required by fmt, mtime]
- install oseq 0.5.1 [required by regenerate]
- install ounit2 2.2.7 [required by qcheck-ounit]
- install qcheck 0.91 [required by regenerate]
- install qcheck-core 0.91 [required by qcheck]
- install qcheck-ounit 0.91 [required by qcheck]
- install regenerate 0.2
- install seq base [required by containers]
- install stdlib-shims 0.3.0 [required by ounit2]
- install topkg 1.1.1 [required by fmt, mtime]
<><> Processing actions <><><><><><><><><><><><><><><><><><><><><><><><><><><><>
-> retrieved cmdliner.1.3.0 (cached)
-> retrieved containers.2.8.1 (cached)
-> retrieved csexp.1.5.2 (cached)
-> installed csexp.1.5.2
-> retrieved dune-configurator.3.22.0~alpha0 (cached)
-> retrieved fmt.0.11.0 (cached)
-> retrieved iter.1.9 (cached)
-> retrieved mtime.1.4.0 (cached)
-> retrieved ocamlbuild.0.16.1 (cached)
-> retrieved ocamlfind.1.9.8 (cached)
-> retrieved oseq.0.5.1 (cached)
-> retrieved ounit2.2.2.7 (cached)
-> installed cmdliner.1.3.0
-> retrieved qcheck.0.91, qcheck-core.0.91, qcheck-ounit.0.91 (cached)
-> retrieved regenerate.0.2 (cached)
-> retrieved seq.base (cached)
-> installed seq.base
-> retrieved stdlib-shims.0.3.0 (cached)
-> retrieved topkg.1.1.1 (cached)
-> installed iter.1.9
-> installed dune-configurator.3.22.0~alpha0
-> installed oseq.0.5.1
-> installed stdlib-shims.0.3.0
-> installed ounit2.2.2.7
-> installed qcheck-core.0.91
-> installed qcheck-ounit.0.91
-> installed containers.2.8.1
-> installed qcheck.0.91
-> installed ocamlfind.1.9.8
-> installed ocamlbuild.0.16.1
-> installed topkg.1.1.1
-> installed mtime.1.4.0
-> installed fmt.0.11.0
-> installed regenerate.0.2
Done.
# To update the current shell environment, run: eval $(opam env)
2026-03-03 04:13.35 ---> saved as "30d6b5c8a5dd5727beb8eaea1ec7eaace69edc51aa4f9dd1d56e189898c266da"
/home/opam: (run (network host)
(shell "(opam reinstall --with-test regenerate.0.2) || true"))
The following actions will be performed:
=== recompile 1 package
- recompile regenerate 0.2
=== install 1 package
- install re 1.14.0 [required by regenerate]
<><> Processing actions <><><><><><><><><><><><><><><><><><><><><><><><><><><><>
-> retrieved re.1.14.0 (https://opam.ocaml.org/cache)
-> retrieved regenerate.0.2 (https://opam.ocaml.org/cache)
-> removed regenerate.0.2
-> installed re.1.14.0
-> installed regenerate.0.2
Done.
# To update the current shell environment, run: eval $(opam env)
2026-03-03 04:15.06 ---> saved as "e77984aa469ca867d967939597a0be7a7eff3a6e7242ce9e1c0691ca8e7a607a"
/home/opam: (run (shell "opam reinstall --with-test --verbose regenerate.0.2;\
\n res=$?;\
\n test \"$res\" != 31 && exit \"$res\";\
\n export OPAMCLI=2.0;\
\n build_dir=$(opam var prefix)/.opam-switch/build;\
\n failed=$(ls \"$build_dir\");\
\n partial_fails=\"\";\
\n for pkg in $failed; do\
\n if opam show -f x-ci-accept-failures: \"$pkg\" | grep -qF \"\\\"debian-13\\\"\"; then\
\n echo \"A package failed and has been disabled for CI using the 'x-ci-accept-failures' field.\";\
\n fi;\
\n test \"$pkg\" != 'regenerate.0.2' && partial_fails=\"$partial_fails $pkg\";\
\n done;\
\n test \"${partial_fails}\" != \"\" && echo \"opam-repo-ci detected dependencies failing: ${partial_fails}\";\
\n exit 1"))
The following actions will be performed:
=== recompile 1 package
- recompile regenerate 0.2
<><> Processing actions <><><><><><><><><><><><><><><><><><><><><><><><><><><><>
Processing 1/4: [regenerate.0.2: extract]
-> retrieved regenerate.0.2 (cached)
Processing 2/4: [regenerate: dune build]
+ /home/opam/.opam/opam-init/hooks/sandbox.sh "build" "dune" "build" "-p" "regenerate" "-j" "71" (CWD=/home/opam/.opam/4.14/.opam-switch/build/regenerate.0.2)
- (cd _build/default && /home/opam/.opam/4.14/bin/ocamlc.opt -w -40 -g -bin-annot -I lib/.regenerate.objs/byte -I /home/opam/.opam/4.14/lib/containers -I /home/opam/.opam/4.14/lib/containers/data -I /home/opam/.opam/4.14/lib/containers/iter -I /home/opam/.opam/4.14/lib/containers/monomorphic -I /home/opam/.opam/4.14/lib/fmt -I /home/opam/.opam/4.14/lib/iter -I /home/opam/.opam/4.14/lib/oseq -I /home/opam/.opam/4.14/lib/ounit2 -I /home/opam/.opam/4.14/lib/ounit2/advanced -I /home/opam/.opam/4.14/lib/qcheck -I /home/opam/.opam/4.14/lib/qcheck-core -I /home/opam/.opam/4.14/lib/qcheck-core/runner -I /home/opam/.opam/4.14/lib/qcheck-ounit -I /home/opam/.opam/4.14/lib/seq -I /home/opam/.opam/4.14/lib/stdlib-shims -I segments/.segments.objs/byte -no-alias-deps -open Regenerate__ -o lib/.regenerate.objs/byte/regenerate__Regex.cmo -c -impl lib/regex.ml)
- File "lib/regex.ml", line 87, characters 14-23:
- 87 | let opt a = frequency [ 1, pure None ; 1, map CCOpt.return a] in
- ^^^^^^^^^
- Alert deprecated: QCheck.Gen.frequency
- Use [oneof_weighted] instead
- File "lib/regex.ml", line 97, characters 14-23:
- 97 | let gbase = frequency [
- ^^^^^^^^^
- Alert deprecated: QCheck.Gen.frequency
- Use [oneof_weighted] instead
- File "lib/regex.ml", line 105, characters 6-15:
- 105 | frequency [
- ^^^^^^^^^
- Alert deprecated: QCheck.Gen.frequency
- Use [oneof_weighted] instead
- (cd _build/default && /home/opam/.opam/4.14/bin/ocamlopt.opt -w -40 -g -O3 -inlining-report -I lib/.regenerate.objs/byte -I lib/.regenerate.objs/native -I /home/opam/.opam/4.14/lib/containers -I /home/opam/.opam/4.14/lib/containers/data -I /home/opam/.opam/4.14/lib/containers/iter -I /home/opam/.opam/4.14/lib/containers/monomorphic -I /home/opam/.opam/4.14/lib/fmt -I /home/opam/.opam/4.14/lib/iter -I /home/opam/.opam/4.14/lib/oseq -I /home/opam/.opam/4.14/lib/ounit2 -I /home/opam/.opam/4.14/lib/ounit2/advanced -I /home/opam/.opam/4.14/lib/qcheck -I /home/opam/.opam/4.14/lib/qcheck-core -I /home/opam/.opam/4.14/lib/qcheck-core/runner -I /home/opam/.opam/4.14/lib/qcheck-ounit -I /home/opam/.opam/4.14/lib/seq -I /home/opam/.opam/4.14/lib/stdlib-shims -I segments/.segments.objs/byte -I segments/.segments.objs/native -intf-suffix .ml -no-alias-deps -open Regenerate__ -o lib/.regenerate.objs/native/regenerate__Regex.cmx -c -impl lib/regex.ml)
- File "lib/regex.ml", line 87, characters 14-23:
- 87 | let opt a = frequency [ 1, pure None ; 1, map CCOpt.return a] in
- ^^^^^^^^^
- Alert deprecated: QCheck.Gen.frequency
- Use [oneof_weighted] instead
- File "lib/regex.ml", line 97, characters 14-23:
- 97 | let gbase = frequency [
- ^^^^^^^^^
- Alert deprecated: QCheck.Gen.frequency
- Use [oneof_weighted] instead
- File "lib/regex.ml", line 105, characters 6-15:
- 105 | frequency [
- ^^^^^^^^^
- Alert deprecated: QCheck.Gen.frequency
- Use [oneof_weighted] instead
- (cd _build/default && /home/opam/.opam/4.14/bin/ocamlc.opt -w -40 -g -bin-annot -I lib/.regenerate.objs/byte -I /home/opam/.opam/4.14/lib/containers -I /home/opam/.opam/4.14/lib/containers/data -I /home/opam/.opam/4.14/lib/containers/iter -I /home/opam/.opam/4.14/lib/containers/monomorphic -I /home/opam/.opam/4.14/lib/fmt -I /home/opam/.opam/4.14/lib/iter -I /home/opam/.opam/4.14/lib/oseq -I /home/opam/.opam/4.14/lib/ounit2 -I /home/opam/.opam/4.14/lib/ounit2/advanced -I /home/opam/.opam/4.14/lib/qcheck -I /home/opam/.opam/4.14/lib/qcheck-core -I /home/opam/.opam/4.14/lib/qcheck-core/runner -I /home/opam/.opam/4.14/lib/qcheck-ounit -I /home/opam/.opam/4.14/lib/seq -I /home/opam/.opam/4.14/lib/stdlib-shims -I segments/.segments.objs/byte -no-alias-deps -open Regenerate__ -o lib/.regenerate.objs/byte/regenerate__Langgen.cmo -c -impl lib/langgen.ml)
- File "lib/langgen.ml", line 69, characters 19-27:
- 69 | Fmt.iter ~sep:(Fmt.unit ", ") (CCFun.flip Segment.to_iter) Word.pp
- ^^^^^^^^
- Alert deprecated: Fmt.unit
- use Fmt.any instead.
- File "lib/langgen.ml", line 71, characters 17-25:
- 71 | let pp_sep = Fmt.unit "@." in
- ^^^^^^^^
- Alert deprecated: Fmt.unit
- use Fmt.any instead.
- File "lib/langgen.ml", line 375, characters 31-37:
- 375 | let re = Regex.gen ~compl (oneofl alphabet) st in
- ^^^^^^
- Alert deprecated: QCheck.Gen.oneofl
- Use [oneof_list] instead
- File "lib/langgen.ml", line 378, characters 51-55:
- 378 | Fmt.epr "@[<2>%s:@ %a@]@." s Fmt.(list ~sep:(unit ",@ ") W.pp) l
- ^^^^
- Alert deprecated: Fmt.unit
- use Fmt.any instead.
- (cd _build/default && /home/opam/.opam/4.14/bin/ocamlc.opt -w -40 -g -bin-annot -I bin/.gen_re.eobjs/byte -I /home/opam/.opam/4.14/lib/cmdliner -I /home/opam/.opam/4.14/lib/containers -I /home/opam/.opam/4.14/lib/containers/data -I /home/opam/.opam/4.14/lib/containers/iter -I /home/opam/.opam/4.14/lib/containers/monomorphic -I /home/opam/.opam/4.14/lib/fmt -I /home/opam/.opam/4.14/lib/fmt/tty -I /home/opam/.opam/4.14/lib/iter -I /home/opam/.opam/4.14/lib/mtime -I /home/opam/.opam/4.14/lib/mtime/clock/os -I /home/opam/.opam/4.14/lib/oseq -I /home/opam/.opam/4.14/lib/ounit2 -I /home/opam/.opam/4.14/lib/ounit2/advanced -I /home/opam/.opam/4.14/lib/qcheck -I /home/opam/.opam/4.14/lib/qcheck-core -I /home/opam/.opam/4.14/lib/qcheck-core/runner -I /home/opam/.opam/4.14/lib/qcheck-ounit -I /home/opam/.opam/4.14/lib/seq -I /home/opam/.opam/4.14/lib/stdlib-shims -I lib/.regenerate.objs/byte -I segments/.segments.objs/byte -no-alias-deps -o bin/.gen_re.eobjs/byte/gen_re.cmo -c -impl bin/gen_re.ml)
- File "bin/gen_re.ml", line 139, characters 39-47:
- 139 | |> Fmt.pr "%a@." (CCFormat.seq ~sep:(Fmt.unit "@.") W.pp)
- ^^^^^^^^
- Alert deprecated: Fmt.unit
- use Fmt.any instead.
- File "bin/gen_re.ml", line 181, characters 4-13:
- 181 | Term.info "generate"
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.info
- Use Cmd.info instead.
- File "bin/gen_re.ml", line 189, characters 4-13:
- 189 | Term.info "count"
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.info
- Use Cmd.info instead.
- File "bin/gen_re.ml", line 197, characters 4-13:
- 197 | Term.info "profile"
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.info
- Use Cmd.info instead.
- File "bin/gen_re.ml", line 206, characters 13-22:
- 206 | let info = Term.info "regenerate" ~doc in
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.info
- Use Cmd.info instead.
- File "bin/gen_re.ml", line 210, characters 9-18:
- 210 | let () = Term.exit @@ Term.eval_choice default_cmd cmds
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.exit
- Use Stdlib.exit and Cmd.eval instead.
- File "bin/gen_re.ml", line 210, characters 22-38:
- 210 | let () = Term.exit @@ Term.eval_choice default_cmd cmds
- ^^^^^^^^^^^^^^^^
- Alert deprecated: Cmdliner.Term.eval_choice
- Use Cmd.group and one of Cmd.eval* instead.
- (cd _build/default && /home/opam/.opam/4.14/bin/ocamlopt.opt -w -40 -g -O3 -inlining-report -I lib/.regenerate.objs/byte -I lib/.regenerate.objs/native -I /home/opam/.opam/4.14/lib/containers -I /home/opam/.opam/4.14/lib/containers/data -I /home/opam/.opam/4.14/lib/containers/iter -I /home/opam/.opam/4.14/lib/containers/monomorphic -I /home/opam/.opam/4.14/lib/fmt -I /home/opam/.opam/4.14/lib/iter -I /home/opam/.opam/4.14/lib/oseq -I /home/opam/.opam/4.14/lib/ounit2 -I /home/opam/.opam/4.14/lib/ounit2/advanced -I /home/opam/.opam/4.14/lib/qcheck -I /home/opam/.opam/4.14/lib/qcheck-core -I /home/opam/.opam/4.14/lib/qcheck-core/runner -I /home/opam/.opam/4.14/lib/qcheck-ounit -I /home/opam/.opam/4.14/lib/seq -I /home/opam/.opam/4.14/lib/stdlib-shims -I segments/.segments.objs/byte -I segments/.segments.objs/native -intf-suffix .ml -no-alias-deps -open Regenerate__ -o lib/.regenerate.objs/native/regenerate__Langgen.cmx -c -impl lib/langgen.ml)
- File "lib/langgen.ml", line 69, characters 19-27:
- 69 | Fmt.iter ~sep:(Fmt.unit ", ") (CCFun.flip Segment.to_iter) Word.pp
- ^^^^^^^^
- Alert deprecated: Fmt.unit
- use Fmt.any instead.
- File "lib/langgen.ml", line 71, characters 17-25:
- 71 | let pp_sep = Fmt.unit "@." in
- ^^^^^^^^
- Alert deprecated: Fmt.unit
- use Fmt.any instead.
- File "lib/langgen.ml", line 375, characters 31-37:
- 375 | let re = Regex.gen ~compl (oneofl alphabet) st in
- ^^^^^^
- Alert deprecated: QCheck.Gen.oneofl
- Use [oneof_list] instead
- File "lib/langgen.ml", line 378, characters 51-55:
- 378 | Fmt.epr "@[<2>%s:@ %a@]@." s Fmt.(list ~sep:(unit ",@ ") W.pp) l
- ^^^^
- Alert deprecated: Fmt.unit
- use Fmt.any instead.
- (cd _build/default && /home/opam/.opam/4.14/bin/ocamlopt.opt -w -40 -g -O3 -inlining-report -I bin/.gen_re.eobjs/byte -I bin/.gen_re.eobjs/native -I /home/opam/.opam/4.14/lib/cmdliner -I /home/opam/.opam/4.14/lib/containers -I /home/opam/.opam/4.14/lib/containers/data -I /home/opam/.opam/4.14/lib/containers/iter -I /home/opam/.opam/4.14/lib/containers/monomorphic -I /home/opam/.opam/4.14/lib/fmt -I /home/opam/.opam/4.14/lib/fmt/tty -I /home/opam/.opam/4.14/lib/iter -I /home/opam/.opam/4.14/lib/mtime -I /home/opam/.opam/4.14/lib/mtime/clock/os -I /home/opam/.opam/4.14/lib/oseq -I /home/opam/.opam/4.14/lib/ounit2 -I /home/opam/.opam/4.14/lib/ounit2/advanced -I /home/opam/.opam/4.14/lib/qcheck -I /home/opam/.opam/4.14/lib/qcheck-core -I /home/opam/.opam/4.14/lib/qcheck-core/runner -I /home/opam/.opam/4.14/lib/qcheck-ounit -I /home/opam/.opam/4.14/lib/seq -I /home/opam/.opam/4.14/lib/stdlib-shims -I lib/.regenerate.objs/byte -I lib/.regenerate.objs/native -I segments/.segments.objs/byte -I segments/.segments.objs/native -intf-suffix .ml -no-alias-deps -o bin/.gen_re.eobjs/native/gen_re.cmx -c -impl bin/gen_re.ml)
- File "bin/gen_re.ml", line 139, characters 39-47:
- 139 | |> Fmt.pr "%a@." (CCFormat.seq ~sep:(Fmt.unit "@.") W.pp)
- ^^^^^^^^
- Alert deprecated: Fmt.unit
- use Fmt.any instead.
- File "bin/gen_re.ml", line 181, characters 4-13:
- 181 | Term.info "generate"
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.info
- Use Cmd.info instead.
- File "bin/gen_re.ml", line 189, characters 4-13:
- 189 | Term.info "count"
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.info
- Use Cmd.info instead.
- File "bin/gen_re.ml", line 197, characters 4-13:
- 197 | Term.info "profile"
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.info
- Use Cmd.info instead.
- File "bin/gen_re.ml", line 206, characters 13-22:
- 206 | let info = Term.info "regenerate" ~doc in
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.info
- Use Cmd.info instead.
- File "bin/gen_re.ml", line 210, characters 9-18:
- 210 | let () = Term.exit @@ Term.eval_choice default_cmd cmds
- ^^^^^^^^^
- Alert deprecated: Cmdliner.Term.exit
- Use Stdlib.exit and Cmd.eval instead.
- File "bin/gen_re.ml", line 210, characters 22-38:
- 210 | let () = Term.exit @@ Term.eval_choice default_cmd cmds
- ^^^^^^^^^^^^^^^^
- Alert deprecated: Cmdliner.Term.eval_choice
- Use Cmd.group and one of Cmd.eval* instead.
Processing 2/4: [regenerate: dune runtest]
+ /home/opam/.opam/opam-init/hooks/sandbox.sh "build" "dune" "runtest" "-p" "regenerate" "-j" "71" (CWD=/home/opam/.opam/4.14/.opam-switch/build/regenerate.0.2)
- (cd _build/default/test/re && ./test_re.exe -v --long)
-
random seed: 75029140
- generated error fail pass / total time test name
-
[ ] 0 0 0 0 / 100 0.0s anon_test_1
[ ] 48 0 0 36 / 100 0.1s anon_test_1 (collecting)
[ ] 107 0 0 76 / 100 0.2s anon_test_1 (collecting)
[ ] 134 0 0 91 / 100 0.3s anon_test_1 (collecting)
[✓] 146 0 0 100 / 100 0.4s anon_test_1
- ================================================================================
- success (ran 1 tests)
- Regex: [^ca]a|a|a
- Pos:
- Neg: aa, aba, bca, bcb, cab, aabb, acba, bacc, bbaa, bbab, bbac, bcbc, caca,
- cacb, cbcb, ccca, aaacb, aacaa, aacca, abbac, abcbb, abccc, acbac, baaba,
- baaca, bacca, bbabb, bbabc, bbbcb, bcaaa, bccbb, caaba, caabc, cacba,
- cacbb, caccb, cbaaa, cbaac, cbbca, cbbcc, cbcbb, ccabb, ccabc, ccbca,
- cccac, ccccb, aaaaac, aaabba
- Regex: (c*)a
- Pos: cccccccccccccccca, ccccccccccccccccccca, ccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca
- Neg: bc, cc, acc, bab, bbc, aabc, abcc, acac, accb, baaa, bbbc, bccc, caac,
- cabb, caca, cbcb, aaaac, aaaba, aaaca, aabcc, aacbb, abaab, ababa, abbba,
- abcbc, acbac, accba, accca, babaa, babbb, babcb, baccc, bbabc, bbaca,
- bbacb, bbbcb, cabcb, cacbc, cbaba, cbbaa, cbcba, ccbbb, ccbca, aaabbc,
- aabbbb, aabcac, aabccb, aacaaa, aacabc, aacaca, aaccac, ababba, abacbb,
- abacca, abbaaa, abbbbb, abccca, acaaca, acbacb, accaab, accaca, accbac,
- accbca, baaaca, baabcc, baacac, baacbb, babbba, babbcc, bacaaa, bacbbb,
- bacbbc, baccaa, baccac, baccca, bbaaac, bbaaca, bbaccc, bbbacc, bbcaab,
- bbcbba, bbccba, bcaaac, bcacaa, bcbbca, bcbbcb, bcbcca, bccacc, bccbcc,
- bcccbb, caaaaa, caaacc, caabba, caacba, cababa, cabaca, cabacc, cabbba,
- cabcac, cabcbb, cabccb, cacacc, cacbbb, cacbbc, caccba, caccbb
- Regex: [acb]a(a|[^abc])|[cba]|εa{2,3}
- Pos: ba
- Neg: abcc, acac, bbcb, caca, cacb, ccca, aabca, aabcb, aabcc, aaccc, abbab,
- abbcc, acbba, accca, babcc, bacca, bcaba, bcbcc, bccbb, bccca, bcccc,
- cbabc, cbbba, cbbbb, cbcab, cbcbb, ccabc, ccbbb, cccba, ccccb, ccccc,
- aaaacc, aaabab, aaabbc, aaacba, aaaccc, aabaab, aababb, aabcaa, aabcac,
- aabcba, aaccba, abaaab, abacab, abbaaa, abbbbc, abbcaa, abbcca, abcabb,
- abcacc, abcbcb, abcbcc, acaaaa, acaccb, acbaac, acbabc, acbaca, acbbbb,
- acbbcb, acbccb, accaac, accbcb, baabba, baabca, baacba, baacbc, bababb,
- bababc, bacaab, bacbab, bbaaac, bbaacc, bbabbb, bbacab, bbacac, bbacbc,
- bbbaba, bbbacc, bbbbaa, bbbbba, bbbbcc, bbbcca, bbbccb, bbcaaa, bbcbac,
- bbcbcb, bcaabb, bcabab, bcacaa, bcacab, bcbabc, bcbacc, bccabc, bccacb,
- bccbab, bccbbb, bcccba, caaabc, caabac, caabba, caabbb, caabcc, cabaac,
- cabbcb, cabcac, cabcbb, cacabb, cacbac, cacbcc, caccac, caccca, cacccb,
- cbaaaa, cbabba, cbacba, cbbaab, cbbacb, cbbbca, cbbcab, cbbcbb, cbcabb,
- cbcbbc, cbccac, cbccba, cbcccc, ccaaab, ccabba, ccabbb, ccbacc, ccbbaa,
- ccbbac, ccbcab, cccbaa, aaaacca, aaababc, aaabbba, aaabcac
- Regex: ([bca]&[^bc]&([^cab]|c+))|((b[^bac]{2,})&b|c){0,5}
- Pos:
- Neg: ca, aac, accb, baaa, bbbc, bbcb, bcaa, cccb, aaaaa, aabaa, aacbc, aaccc,
- abbbb, abcab, accaa, acccc, babac, bacab, bacca, bbcca, bbccc, bcbac,
- bccbb, caaba, cabcb, cacbc
- Regex: (ac[acb][^cab]{3})(a|a|ac)*
- Pos:
- Neg: c, bc, acb, bca, ccc, aacc, abba, acba, bbbb, bccc, caab, cbac, ccba,
- aaaac, aaacc, aacac, aaccb, abcaa, abcac, acbcb, accba, accbb, accca,
- baaac, baaca, babab, baccc, bbbac, bbbba, bbcca, bcaba, bcabb, bccba,
- caabc, caacc, cabca, cacac, cbaca, cbbbb, cbcac, ccaac, aaaaba, aaabcc,
- aaacbc, aababc, aabacb, aabbaa, aabbcb
- Regex: [bac]ε
- Pos:
- Neg: ab, ba, abc, acc, ccc, aaab, aaac, abab, babc, bcaa, bcab, cacb, ccab,
- ccca, aaaaa, aaacc, aabcc, abacc, acaac, acbbc, acccc, baaca, babab, babba,
- baccc, bbbbc, bbcbc
- Regex: c*
- Pos: cccccccccccccc, ccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc,
- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
- Neg: ba, acb, bcc, cba, aaac, acac, babb, bacc, bbba, bbca, bcaa, ccac,
- aabbb, aabca, aacbc, abaca, abbaa, abbbc, abcaa, abccc, acbbc, acbca,
- baccc, bbaab, bbabb, bbaca, bbbaa, bbbbc, bbbca, bccaa, caaaa, caaca,
- cabca, cacac, cbbaa, cbbbc, cbcaa, cbccc, ccaab, ccabb, ccabc, ccacb,
- ccbaa, cccbc, aaacaa, aaacac, aaaccb, aabacc, aacbab, aacbbb, aaccaa,
- abaaab, abacac, abbabb, abbbbb, abbcbb, abcabb, abcacc, abcbcb, abccac,
- abccba, acaaaa, acabba, acabcc, acbaba, acbbba, acbbbc, acbbcc, acbcab,
- acbcbb, accaaa, accabb, accaca, accacc, accbcc, acccbc, accccb, baaaaa,
- baaabb, baabbc, baacac, baacbc, babaac, babaca, babbba, babcab, babccb,
- bacabb, bacaca, baccaa, bbaaab, bbaaca, bbabba, bbcabc, bbccaa, bbccbb,
- bcaaac, bcaaca, bcbcbc, bccbcc, bcccab, bcccbb, caacab, cabbbc, cabbca,
- cabbcc, cabcbb, cacbbc
- Regex: ([^ba]{2,})ca
- Pos: cccca, cccccccccccca, cccccccccccccca, cccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca,
- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca
- Neg: c, bcc, aaaa, aaac, aabc, aacc, accc, babb, bacc, bbac, bbcb, bcaa,
- bcab, cbca, aaaac, aacab, abcba, acaaa, acaab, acbac, baaba, baabc, baaca,
- babcb, bacbb, bbbab, bbbac, bbbbc, bbcab, bbcac, bbcba, bcbaa, bcbba,
- bccca, bcccc, caaba, cabba, cbbab, cbbba, cbbbb, cbcaa, ccabb, ccbab,
- cccaa, cccab, aaaaba, aaaabb, aaabbb, aaabca, aaabcb, aabaaa, aabaab,
- aabbba, aacaba, ababbb, ababca, abbbba, abbcbb, abcaca, abcbbb, abccba,
- acaabc, acabac, acacac, acbcca, accabc, acccab, acccba, baacbc, baaccc,
- babacc, babcac, bacabc, bacbac, bacbcc, bacccb, bbaaaa, bbaabc, bbacba,
- bbbacb, bbbbac, bbcaba, bbccbc, bcabbb, bcacbc, bcaccb, bcbabc, bcbcab
- Regex: ([acb]ε&[^abc][ba]{3,})([^bca][^cb](bb+){0})
- Pos:
- Neg: ccb, aaaa, aabb, aaca, acbc, caaa, cacb, cacc, cccb, aaaab, aaacb,
- acaab, acbac, accac, babaa, babba, babbb, bbaaa, bbaac, bbabc, bbaca,
- bbbbb, bbbcb, bcabb, bccca, caabb, cacbb, cbaab, cbaba, cbcaa, cbcba,
- cbccb, ccbab, ccbcc, cccab, cccac, aaabab, aaabac, aabaaa, aabbcc, aabcab,
- aabcba, aacaaa, aacbac, aacbca, aaccab, abaaca, abacaa, abbbcc, abbccb,
- abccba, acaaba, acbccb, accbbc, accbcc, baaabb, baaacc, babbaa, babbba,
- babcaa, babcab, babcac, babcbb, bacacc, bbaabb, bbaabc, bbabcb, bbaccc,
- bbbbac, bbbbbb, bbbbcb, bbbcbb, bbcaab, bbcabc, bbcbbc, bcaabc, bcabac,
- bcbaac, bcbcab, bcbcac, bccbab, bccbca, caabcb, caaccb, cbaaac, cbabba,
- cbabcb, cbacbb, cbbbac, cbbccb, cbcaab, cbcbba, cbcbbc, cbccba, cbccbb,
- ccaaac, ccaacb, ccabaa, ccabba, ccbaaa, ccbaac, ccbbba, cccaaa, cccaab,
- cccbac, cccbca, aaaaacb, aaaabba, aaabbba, aaabbbb, aaabbbc, aaabcaa,
- aaabcac, aaacaab, aaaccca, aabaaca, aabaacc, aababaa, aabbacb, aabbbcc,
- aabcbca, aabccac, aabccbc, aabcccb, aacaacc, aacabbc, aacbacb, aacbcaa,
- aacbcab, aacbcba, aaccaaa, aaccbca, aacccab, aacccca, abaabcc, abaacaa,
- abaacbc, ababaaa, ababaca, ababbab, ababccb, abacabb, abacbac, abacbba,
- abaccac, abbbabc, abbbbbb, abbbccc, abbcaca, abbccbc, abbcccb, abcaaac,
- abcabba, abcabca, abcbbca, abcbcaa, abcbcbc, abcbcca, abccaac, acaabbb
- Regex: ((a&[^ab])|[bc]c)([^acb]a{3,})a*
- Pos:
- Neg: ac, aba, abc, bac, acba, bacb, bbbc, bcca, aaaac, aaaba, aabaa, aaccb,
- ababa, abbaa, abbba, abbbb, acbaa, acbac, accab, accac, accbb, baaba,
- bacac, baccc, bbabb, bbbbc, bbbca, bbbcb, bcaaa, bcbbb, caabc, cabcc,
- cacca, cbaca, cbccb, ccabc, ccacc, ccbcc, cccca, aaacab, aaaccc, aababc,
- aabacc, aabbaa, aabbba, aabcbb, aacbab, aacbcb, abacbc, abbbac, abbbbb,
- abbcbc, abcaba, abcaca, abcbaa, acabca, acabcc, acacaa, acbaab, accaab,
- acccac, baaaab, baaaca, baabbb, babaab, bababc, babaca, babbbb, babcab,
- babcac, babcbc, babcca, bacaba, bacacb, bacacc, bacbba, bacbbc, baccaa,
- baccbc, bbacca, bbbbba, bbcabc, bbcbcb, bcaaaa, bcaaba, bcaabb, bcaacb,
- bcabab, bcabca, bcabcb, bcacbc, bcbaaa, bcbacc, bcbbaa, bcbcbc, bccacc,
- bccbba, bcccac, bccccb, caaacb, caabab, caacba, cabcab, cabcbc, cabcca,
- cacacc, cbaaac, cbabaa
- Regex: (([^abc]*)[ac][^cab]+)|(c|b&(a{1,4}))
- Pos:
- Neg: b, bbc, bca, cac, cba, aacc, abcc, acaa, acbc, baca, bbcb, cacb, cbca,
- cccc, aaaac, aabba, aacbb, abacb, abacc, abbcb, abcba, acaaa, acaca, acccb,
- bacbb, bbaab, bbabc, bbacb, bbbbb, bbbbc, bbcbb, bbcbc, bbccb, bbccc,
- bcabc, bcaca, bcbbb, bcbcc, bccbc, caaba, cacab, cacbb, caccc, cbaaa,
- cbaab, cbaac, cbabb, cbbca, cbbcc, cbcac, ccaba, ccbbb, aaaaba, aaabaa,
- aaabca, aaacca, aabaaa, aabaab
- Regex: ((a&c)|bc)[ca]c[^cab][^acb]
- Pos:
- Neg: ca, aab, baa, cab, ccb, aabc, abac, acab, acac, acba, babc, bbbb, bcaa,
- bcab, ccbb, ccca, aaabc, aabba, aacaa, abacb, abbaa, abbab, acabc, acbbc,
- baaaa
- Regex: cbaca([cab]|b){3,}
- Pos:
- Neg: aa, acbb, baac, bbab, bcaa, ccaa, aaabb, aabab, aabba, aacaa, aaccc,
- abcbb, accaa, accab, baaca, baacc, bbacc, bbcbc, bbccc, bcaca, bcbca,
- bccab, caabb, cabcc, cbaba, cbbaa, cbccb, ccabc, ccbaa, ccbbb, cccba,
- cccbb, aaaabc, aaaacb, aaacbb, aaaccb, aabacc, aabbaa, aabcbb, aabcca,
- aacaaa, aacabc, aacbaa, aacbab, aacbbb, aaccaa, ababbc, ababca, ababcc,
- abacba, abbacc, abcaac, abcbab, abcccb, acabbc, acbbbb, acbccb, accbac,
- accbbc, accbcb, acccab, baaaca, babaac, babbaa, babbbb, babbcb, babccc,
- bacbac, baccac, baccbb, bbaabb, bbabbc, bbacbb, bbacca, bbbaab, bbbbca,
- bbcaaa, bbcaba, bbcbab, bcabbb, bcacac, bcaccb, bcbcac, bccbab, bccbac,
- bccbbb, bcccca, caaaca, caacbc, cabaaa, cabbac, cacaac, caccbb, cbabac,
- cbabba, cbabbb, cbacaa, cbbaca, cbbbaa, cbbbcb, cbbcab, cbccaa, ccaaca,
- ccabab, ccabbc, ccacab, ccacac, ccacbb, ccbaca, ccbcba, ccbccb, cccaac,
- cccaba, cccbab, cccbac, ccccca, aaaaacc, aaaacaa, aaabaab, aaababa,
- aaabacc, aaabbab, aaabbcc, aaabcbb, aaacaac, aaaccaa, aaaccca, aaacccc,
- aabaaab, aabaaac, aabaacc, aababba, aababbc, aabacab, aabaccb, aabbabb,
- aabbcbb, aabbcca, aabcabc, aabcbac, aabcccc, aacabba, aacacab, aacacca,
- aacbaab, aacbaca, aacbbab, aacbbbb, aaccabc, aaccbbb, abaaccc
- Regex: [^b][^c]&[^b]&ε
- Pos:
- Neg: aab, bca, bcb, aaab, abbc, acac, acca, bbcc, bccb, caba, cabc, caca,
- ccab, ccac, aaaac, aabaa, aabca, aacca, abbac, abbbb, abcab, abcbc, acaaa,
- acaab, acbcb, acccb, baaac, babcc, bbabc, bbaca, bbcaa, bcbac, bcbba,
- bcbbb, caabb, caabc, caaca, caacc, cabab, cabcc, cbaaa, cbabb, cbaca,
- cbcac, cbcca, ccabb, ccabc, ccbcb, cccbb, aaaaab, aaabaa, aaacac, aabaaa,
- aabcaa, aabcac, aabcbb, aabccb, aacacc, aacbaa, aaccba, aaccbc, abaaac,
- ababbb, abacbb, abaccb, abbbaa, abbbbc, abbbca, abbcbb, abbcca, abccaa,
- abccbb, acaacb, acaacc, acbaab, acbabc, acbaca, acbcab, accaac, accabb,
- accacb, accbbc, acccba, acccbb, acccca, baabac, baacca, babaac, bababb,
- babcca, babccc, bacaab, bacacb, bacccb, bbaabb, bbabab, bbabbc, bbbaba,
- bbbbab, bbbcbb, bbbccc, bbcabb, bbcabc, bbcbaa, bbcbba, bbcbbb, bbccac,
- bcacba, bcaccb, bcbaaa, bccabb, bccacc, bccbbb, bccbcc, caaaac, caaacc,
- caabcc, caacba, caacbc, cabbaa, cabcbb, cacaba, cacbbc, caccbc, cbaaac,
- cbabcb, cbbabc, cbbcaa, cbbcab, cbbcbc, cbcaac, cbcbbc, ccaaca, ccaacc,
- ccabaa, ccbaaa, ccbbba, ccbbbc, ccbcac, cccbaa, cccbac, cccbbc, ccccaa,
- aaaaaba, aaaacba, aaaacbc, aaabbba, aaabbbb, aaabbcb, aaacbbc, aaaccab,
- aaaccca, aabaacb, aabbacc, aabbbbb
- Regex: ((εb+)&[^abc][bac])ca(c|[^bac])
- Pos:
- Neg: a, ab, bcc, caa, cbc, aaac, abac, acac, acba, acbb, baaa, baac, bacc,
- bcba, caac, caba, cbbc, ccba, aaaaa, aabbc, aacbb, abaab, acbab, acbac,
- acbcb, accbc, acccb, baaab, baacc, bacba, bbbcb, bbcbc
- Regex: ([abc]|[^a])c[^abc]*
- Pos:
- Neg: bb, aca, cac, cbb, abaa, abab, acac, acba, accb, baca, bacb, bbbb, bcab,
- bcac, bccc, caac, cabb, aaaaa, aabbb, aabca, aacac, aacca, abaac, acbab,
- acbcb, accac, baacc, babab, babcc, bacac, bbccc, bcbba, bcbca, caccc,
- cbaac, cbaca, cbacb, cbcbb, ccaab, ccaba, aaaaaa, aaaaab, aaaaca, aaaacc,
- aaabca, aaaccc, aabcaa, aacbaa, aacbac, abaaba, abaacc, abacab, abacbb,
- abacbc, abbacc, abcaca, acaaac, acacaa, acacab, acbabc, acbcac, acbcca,
- acccac, baaaaa, baabac, baabba, baacbb, bababa, bacacb, baccaa, baccab,
- baccba, baccbc, bbaaaa, bbabbb, bbbabb, bbbbab, bbbcca, bbcaab, bbcbab,
- bbcbac, bbccaa, bcaabc, bcaaca, bcabba, bcabca, bcacbc
- Regex: a[^ab](b&c{2,})baεb{2,}
- Pos:
- Neg: bb, aac, abc, aca, bbc, bca, bcc, cba, acac, baaa, babb, bbaa, bbab,
- caca, cbaa, ccca, aaacb, aaacc, aacab, aaccb, aaccc, abaab, ababa, abaca,
- abbbb, abcbb, abccb, acaba, acacc, acbab, accab, accbb, bacab, bacca,
- bbaac, bbabc, bbcaa, bcaab, bcabc, bccbc, caaab, cabcb, cacaa, cacba,
- caccc, cbacb, cbbab, cbbba, cbbbb, cbcbc, ccabb, aaaabb, aaaaca, aaaacb,
- aaabac, aababb, aabacc, aabbbb, aabcaa, aabcac, aacaaa, aacabc, aacaca,
- aacbba, abaabb, abaaca, ababab, abacaa, abaccc, abbaac, abbacb, abbacc,
- abbbaa, abbbac, abbcbc, abcacc, abcbbb, abccaa, acabcb, acaccc, acbbba,
- acbcac, accacb, baacac, baacba, babaab, babacb, babbcc, bacbcc, bbabab,
- bbabbb, bbcbbc, bbcbca, bbcbcc, bbccba, bbccbb, bcabbc, bcabcc, bcbbaa,
- bccaab, bccaca, bccbab, bccbbc, bcccab, caaaaa, caabbb, caaccc, cabaac,
- cabbca, cabbcb, cacaac, cacabc, cacaca, cbaaca, cbabaa, cbabba, cbabcb,
- cbbaca, cbbbba, cbbbbc, cbbbca, cbbcca, cbcacb, cbcbbc, ccabca, ccabcb,
- ccacbb, ccbbba, ccbcaa, ccbcba, cccbba, cccbcc, ccccbc, aaaaaac, aaaaacb,
- aaaabcb, aaaaccb, aaababc, aaabbcb, aaabccc, aabaaab, aababaa, aababac,
- aababcb, aabacba, aabbaaa, aabbaab, aabcacb, aabcbbc, aabccba, aabccbc,
- aabcccb, aacabac, aacabbc, aacbacc, aacbbcc, aacbcaa, aacbccb, aaccabb,
- aaccaca, aacccba, abaaaaa, abaaaab, abaaabc, abaacbc, ababacc, ababbaa,
- abacaba, abacbaa, abbaacc, abbacaa, abbbaac, abbbaba, abbbbaa, abbbcac,
- abbbcbc, abbbccb, abbbccc, abbcaaa, abbcbaa, abbcbbb, abbccba, abbccbb,
- abbccbc, abcaaca, abcabbb, abcbcac, abccaba, abccaca, abccbab, abccbba,
- abccbbb, abcccab, acaaccb, acabcaa, acacabc, acacbab, acacbbb, acacbcb,
- acaccba, acbaaaa, acbaabb, acbabbc, acbacbb, acbacbc, acbbaab, acbbabb,
- acbbccc, acbcabc, acbcaca, acbcbbc, acbccaa, acbccab, accabcb, accabcc,
- accacca, accbaaa, accbbab, accbcac, accbcbb, acccbab, accccaa, accccac,
- baaabcc, baaacba, baabaaa, baabbab, baabbca, baabcaa, baabcba, baabcca,
- baaccab, baaccba, baaccbb, babaaaa, babaaba, babaacb, babacaa, babbaac,
- babbabb, babbacb, babbbab, babcabc, babcaca, babcbaa, babcbac, babccba,
- bacaaac, bacacbc, bacbaca, bacbbca, bacbcaa, baccbca, bacccab, bbaaaaa,
- bbaaabc, bbaacbb, bbacbac, bbacbbb, bbbaaba, bbbacac, bbbbaaa, bbbbbab,
- bbbbcac, bbbcacb, bbbcacc, bbbcbab, bbbcbca, bbbcbcc, bbbccaa, bbbccab,
- bbbcccb, bbcabaa, bbcabab, bbcacac, bbcbbaa, bbcbcab, bbcbcca, bbccbaa,
- bbccbac, bbccbca, bbcccbb, bcaaabb
- Regex: [^acb][ab]|[cab]|c&c
- Pos:
- Neg: ac, aca, baa, bcc, aaca, abab, abbb, abca, acac, baac, babc, bcab, bcac,
- cbac, ccac, aacba, abacb, abacc, abbca, abcbb, abcbc, acaab, accaa, accab,
- accbc, acccc, bbaab, bcabb, bcbbb, bcbcb, bccba, caabb, cbaba, cbcbc,
- ccaac, ccaca, ccacb, ccbbb, cccca, aaaabc, aaabbb, aaabcb, aaacac, aababa,
- aabbac, aabbbc, aabbcc, aabcba, aabcca, aabccc, aacacb, aaccca, aacccb,
- abaaaa, abaaba, ababab, ababbb, ababca, abacbb, abbbba, abbcab, abcaac,
- abcccb, acaaaa, acabba, acacca, acaccb, acbcca, acbccc, accaab, accbab,
- acccbc, baaacc, baacac, babaac, bababb, babbaa, babbac, babcbb, bacabc,
- bacacb, bacbaa, bacbab, bacbca, bbaaca, bbacbb, bbaccb, bbbaaa, bbbacb,
- bbbbac, bbbbba, bbbcac, bbbcbc, bbcbab, bbccbc, bbccca, bcabab, bcabbb,
- bcabcc, bcaccc, bcbbac
- Regex: (c|a)[^acb]b
- Pos:
- Neg: bc, aac, baa, cab, aaba, acbc, baaa, babb, bbab, bbcb, bcbb, bccb, cbaa,
- cbca, aaaac, aaabc, aaacc, aacaa, aacbb, abaab, abaac, ababb, abbcc, abcaa,
- acabc, acbaa, acbbc, acccb, baacb, bacba, bbaab, bbacc, bbbaa, bbccc,
- bcbaa, bcbbb, caaab, caacc, cabcc, cbaba, cbcac, ccaaa, ccaca, ccacb,
- aaaaab, aaaaac, aaaaba, aaabcc, aaacaa, aababc, aabbac, aacaac, aacabc,
- aacbbb, aacccb, ababcc, abacab, abacbb, abbaac, abbabc, abbaca, abbbab,
- abbbba, abbbca, abbcab, abcaba, abcabb, abcabc, abcacb, abccca, acaaca,
- acaacb, acbaac, acbbba, acbbcb, accbca, acccbb, acccbc, baaabc, baaaca,
- baaacb, bababb, bababc, babacb, babbca, bacacb, bacbba, bacbcb, baccac,
- baccbb, bacccb, bbaaab, bbabba, bbabbc, bbbbac, bbbbca, bbbcab, bbcaaa,
- bbcaba, bbcbcc, bbccba, bbcccc, bcabcb, bcaccc, bcbbaa, bcbbba, bcbbbb,
- bcbcac, bcbcbc, bccbaa, bcccab, bcccbb, bccccb, caacab, cabbba, cabbbc,
- cacacc, cacbca, caccca, cbabbb, cbabcc, cbacbc, cbbcbb, cbbccc, ccaaba,
- ccabcb, ccaccb, ccbbaa, cccbbb, cccbcc, ccccac, ccccbc, aaaabca, aaaabcc,
- aaaacbb, aaaacbc, aaabacc, aaabcaa, aaabcbc, aaacacb, aaacbaa, aaacbca,
- aaacbcc, aabaaab, aabaabc, aabaaca, aabaacc, aabacab, aabbaac, aabbacb,
- aabbccb, aabcabb, aabcacb, aacaaaa, aacaaba, aacabcb, aacacac, aacacca,
- aacbaba, aacbcab, aacbccb, aaccaaa, aaccbbb, aaccbcb, aacccac, aaccccc,
- abaacaa, abaaccc, ababbbc, ababbca, ababcca, abacabc, abacbac, abacbcb,
- abaccaa, abaccbc, abacccb, abbaabc, abbabba, abbbabb, abbbacc, abbbbac,
- abbbbca, abbbbcb, abbbcab
- Regex: (ε{1,5})|(b{1,3})|c[cba]|[^bca]ε
- Pos:
- Neg: ab, aab, aba, aca, cac, abab, abca, baaa, bbaa, bbcb, bcbb, bcbc, bccc,
- caca, cacb, cbca, cccc, aaaaa, aaabc, aaacb, aabbb, abbbb, acbbc, baaaa,
- baaac, bacaa, bcbaa, bcbbc, bccbc, caabc, cabca, cabcc, caccb, cbaaa,
- cbaca, cbacb, cbbab, cbbcc, ccaba, ccbab, cccbc, aaabab, aaabba, aaacac,
- aabaab, aabbac, aabcbb, aabccc, aacaaa, aacaab, aacacb, aacbaa, aaccaa,
- aaccca, abaaab, ababba, abacaa, abacbb, abaccc, abbbab, abbbba, abbcbb,
- abcabb, abcbbc, abccbb, abcccb, acaacc, acabaa, acabcb, acacac, acacbb,
- acacca, acbaaa, acbaca, acbbab, accbaa, accbca, acccaa, acccca, baaaab,
- baaabb, baaabc, baabab, baaccc, babbab, babbcb, bacabb, bacbcb, baccca,
- bacccb, bbaaaa, bbabca, bbaccc, bbbacc, bbbbbb, bbbcca, bbcaac, bbccaa,
- bcacbb, bcbaac, bcbbba, bcbbbb, bcbbbc, bcbcca, bcbccb, bccbab, bccbbc,
- caaabc, caacca, cabcba, cacaab, caccab, caccca, cbaaaa, cbaabc, cbabaa,
- cbabab, cbacbb, cbacbc, cbbabc, cbbbbc, cbcaaa, cbcaac, cbcbac, cbcbca,
- cbccbb, cbccbc, ccaabb, ccaaca, ccabac, ccbccc, cccaab, cccbcc, ccccaa,
- ccccca, cccccb, aaaacbb, aaabaab, aaabbaa, aaabccc, aaacbaa, aaacbbc,
- aaaccac, aaaccbc, aabaaaa, aabaaab, aabaacc, aababac, aabacab, aabacac
- Regex: (c|a)([bc]|a)|(b|a)ab
- Pos: ab, ca
- Neg: bb, bbb, caa, cac, ccc, aaaa, aabc, aacc, abab, abac, abca, acbc, acca,
- bacc, bbca, bbcc, caac, cabb, caca, cacc, cbac, ccca, cccb, aaaac, aaacc,
- aabab, aabca, aacca, ababc, abbca, acaac, accac, bacbc, bbaaa, bbaac,
- bbbaa, bbcaa, bbcac, bcabb, bcbcb, caabb, cabab, cabba, cacca, cbcbb,
- ccaaa, ccabc, aaaaac, aaaaba, aaaabb, aaabab, aaabbc, aaabca, aaacbb,
- aaaccc, aababb, aabaca, aabacc, ababbc
- Regex: (([^ac]&a)|[^ba])[^acb][^cb]([^c]c{3,5})
- Pos:
- Neg: ac, ca, cac, cca, aacc, abaa, abba, abcc, acba, acbc, acca, babb, bcaa,
- caca, cacb, ccaa, aabab, aabba, abaaa, abbca, abcbb, acaab, acaba, acbba,
- acbbc, acbcb, accaa, baaaa, baaca, baacb, babbc, bacab, bacac, bbaab,
- bbcbc, bcabc, bcbcb, caaaa, caaba, caabb, caabc, caaca, caacc, cabba,
- cbaac, cbcab, cbcac, cbcbc, ccabc, ccbca, cccbc, aaaaba, aaabca, aaabcc,
- aaaccc, aabacc, aabbcb, aabcaa, aabcba, aabccb, abaabb, ababac, abacbc,
- abbbab, abbbca, abbcbb, abcbab, acaaba, acabaa, acabac, acabba, acabcc,
- acacbc, acbaca, acbbab, acbbac, acbcac, acbcba, acbcca, acccbc, baaaac,
- baaacc, baabac, baacac, babaaa, babbbb, babbbc, babcbb, babccc, bbaaac,
- bbbaba, bbbabb, bbbbbb, bbbcbc, bbbccc, bbcabb, bbcbaa, bbcbca, bbccac,
- bbcccc, bcaaba, bcabab, bcaccb, bcbccb, bccaaa, bccbba, bcccbc, caaaba,
- caabbb, cababa, cababc, cabacc, cabbaa, cabbcc, cabcab, cabcac, cbaaaa,
- cbabac, cbabca, cbacaa, cbacca, cbbbaa, cbbbcb, cbbcca, cbcabb, cbcabc,
- cbcacb, cbcbac, cbccbb, ccaaac, ccaabb, ccaaca, ccbcba, ccbcbb, aaaaccc,
- aaababc, aaabccb, aaacaba, aaacabb, aaacacb, aaacbba, aaacbbc, aaaccbb,
- aabaabb, aabaaca, aabacab, aabacbb, aabacca, aabaccb, aabbcbb, aabccbb,
- aabccca, aacaabb, aacabbc, aacbacb, abaaaab, abaabac, abaaccb, ababaaa,
- ababbbb, ababcab, abacacb, abaccca, abbaaaa, abbaaab, abbaacb, abbacaa,
- abbacca, abcacac, abcbaaa, abcbabb, abcbabc, abcbbcc, abccaba, acaaabc,
- acaacbc, acabbba, acabbcb, acacaac
- Regex: b|b
- Pos:
- Neg: aa, ab, aab, aba, cab, aaab, abba, bbab, bbcb, cbab, cbba, ccab, abcba,
- acaba, acbaa, accab, accba, accca, baabb, babca, babcb, bbaaa, bbabb,
- bbbcb, bcbab
- Regex: c
- Pos:
- Neg: acc, cab, ccc, aaac, abac
- Regex: (a&[^ac]*)[^cba]c
- Pos:
- Neg: a, b, bc, abc, aabc, abba, acab, baac, bcbb, bcca, bccb, caca, cbcb,
- cccc, aabab, aabcb, aacaa, ababa, abbab, abbba, abccb, acbbb, baaca, babba,
- bacca, baccc, bbaac, bbbac, bbccc, bcacc, bcbab, cabbc, cbaaa, cbbac,
- cbbbb, cbbbc, cbbcb, cbccb, aaaaac, aaaaba, aaaacb, aaacab, aabaaa, aabaac,
- aabaca, aabbac, aabcbc, aacaca, aaccaa, aaccac, aaccbc, aaccca, abaabc,
- abacab, abacbb, abbaaa, abbbac, abbbba, abbcaa, abcbac, abcbbc, acaaca,
- acaccb, acbaac, acbbab, acbcbc, acbccc, accaba, accbba, acccaa, baaaac,
- baabbc, baacab, babbaa, babbbb, babccc, bacabb, bacacb, baccbc, bbaabb,
- bbaabc, bbaaca, bbabca, bbacaa, bbbbaa, bbbcba, bbbcbc, bbccbb, bcaacc,
- bcabaa, bcabbc, bcacac, bcaccb, bcbaaa, bcbaca, bcbbba, bccaaa, bccaca,
- bccbbc, bccbcc
- Regex: (b{3,4})&a|ε&([ab]|b)(a&a)
- Pos:
- Neg: c, aa, aba, baa, bab, bca, cca, ccc, aaac, acab, baab, bbbc, bcba, caca,
- cacb, cbaa, aabaa, aabbb
- Regex: (εb[cba]a{1,5})(a[^b]|([^cba][^cb]{3,4}))
- Pos:
- Neg: aaa, bba, cbc, aaac, abca, baab, bacb, bacc, bbbc, cabc, cbbb, cbbc,
- cbca, cbcb, ccaa, ccbb, aaaac, aacaa, acacc, acbaa, acbcc, accbc, acccc,
- baabc, baaca, babcb, bacaa, bacab, bacbc, bbabc, bbacb, bcbba, bccba,
- caabb, cbaac, cbabc, cbcac, cbcba, cbcbc, ccbcb, cccca, aaabbb, aaabbc,
- aaacbb, aabbac, aabcba, aacbac, aaccac, abaaab, ababaa, ababbb, abacbc,
- abbacb, abbbab, abbcab, abbcba, abcaab, abcaca, abcacb, abcbaa, acabba,
- acbaba, acbbaa, acbbab, accaab, accaac, accccb, baaaac, baaacb, baabaa,
- baabab, baabbb, baabcc, baacab, baaccb, bababc, babaca, babcab, babcac,
- babcca, bacbba, bacbcc, bbaaaa, bbaaac, bbabaa, bbaccb, bbbaab, bbbabb,
- bbbbca, bbbccb, bbcbbb, bbcbcb
- Regex: (cb{3,})([^acb]a&ac)
- Pos:
- Neg: cc, bab, cca, ccc, aabb, abaa, abbb, acab, bacb, bbcb, bbcc, bcca, cabc,
- cbca, ccab, aaaaa, aaacc, aabbc, aabcc, abaab, ababc, abbbc, abccc, acaab,
- acaca, bbaca, bcbab, bccbc, cabab, cabca, cacbb, cacbc, cbcca, ccabb,
- ccaca, cccca, aaaaaa, aaabab, aaabba, aaacca, aabaab, aababb, aababc,
- aabbab, aabbba, aacacc, aacbac, aacbbc, aacccc, abaacc, abbaca, abbbbc,
- abcaba, abcabc, abcacc, abcbba, abcccb, acaacb, acacab, acacac, acbbca,
- acbcca, accbaa, accbbb, acccbc, baaaac, baaabb, baabbc, baacba, bababc,
- baccac, bacccc, bbaabb, bbabac, bbabca, bbbabc, bbbacb, bbbbbc, bbbcaa,
- bbbcca, bbcbcc, bbccbb, bbccbc, bcaaac, bcaacc, bcabbc, bcacba, bcacca,
- bcbaac, bcbbaa, bcbccc, bccaab, bccacc, bccbcb, bcccab, bccccb, caabca,
- caacbb, cabaab, cabaca, cabbac, cabbbb, cacbaa, cacbbc, cacbcc, caccba,
- caccbb, cacccc, cbaaab, cbbaba, cbbbca, cbbcbc, cbcaaa, cbcaca, cbcbcc,
- ccabbc, ccabcb, ccacac, ccbaaa, ccbbaa, ccbbac, ccbcba, ccbcbb, ccbccb,
- cccaca, cccacc, cccbba, cccbbb, ccccba, ccccbb, ccccca, aaaaaac, aaaaaba,
- aaabaac, aaabbcc, aaacaab, aaacabb, aaaccba, aabaacb, aababaa, aabaccb,
- aabbaca, aabbbab, aabbbca, aabbcbc, aabbccc, aabcacb, aabcbba, aabcbca,
- aabccab, aabccac, aabcccc, aacaabc, aacbabb, aacbabc, aacbcba, aaccaaa,
- abaaaac, abaabca, abaacaa, ababaab, ababbab, ababbcc, abacaaa, abacaab
- Regex: a|b
- Pos: b
- Neg: bba, cab, abbc, abcc, acaa, acba, bbba, bcac, bcca, cabc, cbba, cbca,
- cbcb, aaabb, aaabc, aaaca, aaacc, aabaa, aabca, abaac, abcac, acabc, acbca,
- baabb, babab, babbc, bacbc, bbabb, bbabc, bbbab, bbcaa, bbcac, bbccb,
- bcabc, bcbab, bcbbb, bccbb, bccca, caaba, ccaaa, ccabb, ccbba, aaaaac,
- aabbaa, aabbbc, aabbca, aabbcb, aacbcb, ababbb, ababcb, abaccc, abbaab,
- abbaba, abbcbb, abcacc, abcbaa, abcbcb, abccaa, acabca, acbcaa, accaaa,
- accabb, accbab, accbba, acccaa, acccab, baabab, baaccb, babaab, babcab,
- bacbba, baccaa, baccab, bacccb, bacccc, bbaabc, bbabab, bbabac, bbbaac,
- bbbabc, bbbacb, bbbbcb, bbbcaa, bbbcab, bbbcac, bbbcba, bbcaba, bbcaca,
- bbccaa, bbccba, bbccbb, bcaabb, bcaabc, bcaaca, bcaacc, bcabba, bcaccb,
- bcbbcb, bcbcbc, bccbbb, bccbcc, bcccab, bcccac, caaaab, caaacb, caaacc,
- cababa, cababb, cababc, cabccb, cacbaa, cacbbc, cbabaa, cbabba, cbabbc,
- cbacaa, cbbaaa, cbbbcb, cbcaaa, ccabac, ccabcb, ccbabc, ccbacb, ccbcbc,
- ccccba, aaaaaac, aaaaabb, aaabaac, aaabaca, aaabbba, aaabcbc, aaacaab,
- aaacaca, aaacbca, aaaccca, aaacccc, aababaa, aababba, aabbbbc, aabbcac,
- aabbccb, aabcaab, aabcbab, aacabaa, aacabab, aacabca, aacbaba, aaccbca,
- abaaaaa, abaaacb, abaabac, abaabba, ababbcc, abacaaa, abacaab, abacbaa,
- abacbcc, abbaaab, abbabaa, abbabba, abbaccc, abbbacc, abbcaab, abbcbba,
- abbcccc, abcaaac, abcaabb, abcaacb, abcabcc, abcaccc, abcbacb, abcbbac,
- abcbbca, abcbcac, abccacb, abccbbb, abccbbc, acaaaca, acaaacc, acaabbc,
- acaabcb, acaacaa, acaacbc, acabaca, acabbbb, acabcbc, acbaaaa, acbaacc,
- acbabac, acbaccc, acbbaac, acbbabb, acbbacc, acbbbcc, acbbcba, acbccab,
- accaaba, accabbb, accacba, accbaab, accbbbb, accbcaa, acccaac, acccaba,
- acccacc, acccccc, baaaaca
- Regex: ([^cba]{1})|(c&[bac])
- Pos:
- Neg: aaa, aca, bba, bcc, cba, aabc, acbc, baac, bccc, cabc, cbaa, cbbb, ccaa,
- ccab, ccac, aabba, aabcc, aacbc, ababc, abcac
- Regex: ([^b]{3,5})(b{2,3})&(ε[^ba]c{2,4})
- Pos:
- Neg: bc, aba, abc, acb, cba, cca, aaba, aabb, aaca, abcb, acaa, acca, babb,
- baca, bacc, bbaa, caaa, caac, ccbb, cccb, aaabb, aabca, aacba, ababb,
- abbcc, abcaa, abcbb, acaca, acacb, acbca, accbc, babcb, bacba, bbbaa,
- bbbbb, bbcca, bcbab, bcbac, bcbcc, bccac, caaac, caabc, caacb, caacc,
- cabaa, cabba, cabbc, cacac, cacbb, cbaab, cbbbb, cccab, ccccb, aabaaa,
- aabacb, aabbba, aabbbb, aabbcb, aabccc
- Regex: [cb][bca]a|[^bca]c|[ab]c{2,}
- Pos: caabaa, caacba, cbabca, acaccba, acbbabc, acbcaac, acbcabc, acbcbba,
- acbccca, acccaac, bbaacbc, bcbaaac, bccaaac, caaacac, ccabcbc, acacbcbc,
- accaabba, acccabba, baaacbca, baaaccaa, baabaabc, baabbaac, baacaabc,
- bbabaabc, bbabcbaa
- Neg: a, ab, abb, bab, caa, cba, cbb, aabc, abaa, abac, abcc, bacb, bbaa,
- caaa, caac, cbaa, cbcb, ccaa, cccc, aaacc, aaccb, abacb, abacc, abbbc,
- abcab, abcba, abcbc, acaaa, acabb, acacb, acbcc, accbc, bacac, bbaab,
- bbbca, bbcac, bbccb, bcaca, bcbbb, bccab, caaca, cabab, cacaa, cacac,
- cbbcb, cbcba, ccaca, ccacb, ccbbc, aaaabc, aaaaca, aaabbb, aaabca, aaacba,
- aababc, aabacc, aabbaa, aabcba, aabcbc, aacaab, aacbbc, aaccbc, aaccca,
- abbaaa, abbaac, abbabb, abbccb, abcacc, abcbbb, acbaac, acbbcc, accaac,
- acccab, baacbc, babbba, bacaab, bacabb, bacbba, baccba, baccca, bbaaac,
- bbaabc, bbbabc, bbbbba, bbcaaa, bbccba, bbcccb, bcaabc, bcabab, bcaccc,
- bcbbaa, bccabc, bccbac, bccccb, caaaab, caabab, caacbb, cabaaa, cacbab,
- cacbac, cacbba, cacbbc, cacbca, cbaaac, cbbabc, cbbaca, cbbbaa, cbbbcc,
- cbbcbb, cbcaac, cbcaca, cbcbbb, cbcbcb, ccaaba, ccaabc, ccaaca, ccabac,
- ccbaba, ccbbba, ccbbbb, ccbcba, ccbcca, ccccac, ccccbc, ccccca, cccccc,
- aaaacaa, aaababb, aaabbca, aaabcca, aaacabb, aaacacb, aaacbba, aaaccaa,
- aabaaac, aababba, aabacba, aabaccb, aabaccc, aabbbaa, aabbbbc, aabbcaa,
- aabcaba, aabccab, aabccca, aacaaaa, aacaabb, aacbbbb, aacbbca, aaccaaa,
- aaccabc, aaccbca, aacccab, aacccca, abaacbb, abababa, abababb, ababaca,
- ababbab, ababbba, ababcbc, ababccb, abacaac, abacbbb, abacbca, abacbcb,
- abaccba, abaccbb, abbaabc, abbacaa, abbacca, abbbbba, abbbcba, abbcaaa,
- abbcbbc, abbccbc, abcaaaa, abcaabc, abcabaa, abcabbb, abcacbb, abcbaac,
- abcbbaa, abcbbba, abcbbbb, abcbbcb, abcbcba, abcbccc, abccacc, abcccaa,
- abcccab, abcccac, acaaabc, acaaaca, acaaacc, acaacbc, acababc, acabbaa,
- acacbbc, acacccb, acbaacc, acbabab, acbacbc, acbbbab, acbbbcc, acbbcac,
- acbbccb, accabbc, accabcc, accaccb, accbbba, accbcaa, accccbb, baaaaca,
- baaabab, baaabac, baaabbb, baaabbc, baaacba, baabbbc, baabcca, baacaca,
- baacbac, baacbbc, baaccba, bababbb, babacba, babaccb, babaccc, babbcbb,
- babbccb, babcbba, babcbbb, babcbcb, bacabcb, bacacac, bacacbb, bacacbc,
- bacbaac, bacbbab, bacbbbc, bacbbcc, bacbcbc, baccabb, baccbaa, bacccac,
- bbaaaac, bbaaabb, bbaabbb, bbaacab, bbaacba, bbaaccb, bbaaccc, bbabbac,
- bbabccb, bbacbab, bbbabaa, bbbbaaa, bbbbbab, bbbbbbc, bbbbcab, bbbcbab,
- bbbccba, bbcaaba, bbcaacc, bbcabbb, bbcacaa, bbcaccb, bbcaccc, bbcbcbc,
- bbccaab, bbccbcc, bbcccbc, bcaaaab, bcaaabb, bcaabac, bcabaaa, bcabcba,
- bcacaab, bcacaba, bcacbab, bcacbcc, bcaccbb, bcaccbc, bcbaabb, bcbaaca,
- bcbabbc, bcbbaaa, bcbbaba, bcbbbbc, bcbcabb, bcbcbac, bcbccbb, bcbcccb,
- bccaacc, bccbaca, bccbbab, bccbccc, bcccabb, bcccbab, bcccccc, caaaabc,
- caabaac, caabbab, caabcaa, caacabc, caacaca, caacacb, caacbaa, caaccab,
- cabaaba, cababbb, cabbaba, cabbbab, cabcbaa, cabccaa, cacaaaa, cacaaab,
- cacaabc, cacabaa, cacabbb, cacabca, cacabcc, cacacaa, cacacac, cacbabc,
- cacbbcc, cacbcab, cacbcba, cacbccc, caccaac, caccaca, caccbbc, cbaaaab,
- cbaaaac, cbaaabb, cbaaacb, cbaabaa, cbaabca, cbabaab, cbabaac, cbababa,
- cbacabb, cbacabc, cbacacc, cbacbac, cbbbbba, cbbbbbc, cbbbcab, cbbbccc,
- cbbccac, cbbccba, cbbccca, cbcabbb, cbcabca, cbcacaa, cbcacba, cbcbaaa,
- cbcbaab, cbcbaba, cbccbaa, cbccbab, cbcccac, ccaabac, ccaacaa, ccaacab,
- ccababc, ccabaca, ccabccc, ccbaaca, ccbbcbc, ccbbcca, ccbccab, ccbccac,
- cccabba
- Regex: (b&[cab])aabac{3,4}
- Pos:
- Neg: c, ab, bb, cc, aab, abc, acb
- Regex: (cc{2,})(c&b)
- Pos:
- Neg: ba, bac, bcb, cac, cca, ccb, abaa, abcc, babb, bbaa, bbbc, bcab, bcba,
- caca, aaaab, aabba, aacac, abbba, acaaa, acbaa, accba, babbc, bbbaa, bbbcc,
- bbcaa, bcaac, bcbba, bcbca, bccaa, caaac, caaca, cbaca, cbbab, cbbba,
- cbbbb, ccabc, cccac, aaaaaa, aaaacc, aaabab, aaabbb, aabbab, aabcca,
- aacaca, aacbaa, aaccbb, abaacb, abacab, abcaca, abcbbb, abccaa, abccbc,
- acaaba, acacaa, acacba, acbbab, acbbba, acbbbb, acbbca, acbcbb, accaab,
- accaac, accacb, accbab, accccc, baaaac, baabab, baabbc, baabcb, baacaa,
- baacca, baaccb, babaab, babbaa, babbba, babbcb, babcaa, babcab, babcca,
- bacbca, bacbcc, baccac, baccbc, bbabab, bbbaaa, bbbbca, bbbcaa, bbbcbc
- Regex: (a|[cba])(a&a){3,}
- Pos: baaaaa, bacaaa, aaaabaca, aaaacaca, aabaaaaa, babacaaa, babacaba,
- bacaaaba, caaacaba, cabaaaca, aaaaaaaaca, aabacaaaba, aabacabaca,
- aabacacaaa, aacaaacaca, baaaaaaaaa, baaabacaaa, babaaacaba, bababababa
- Neg: bb, ca, aaa, aca, baa, bcb, ccc, aaac, aaca, abaa, abba, baab, bacc,
- bccc, cabc, cbaa, ccab, ccca, ababa, ababb, ababc, abacb, abbba, abbcc,
- abcba
- Regex: (c|[acb]{2,})ab(b|[^ab])[^bac]
- Pos:
- Neg: b, c, ba, aac, aacc, abba, acab, babb, bbba, bbbc, bbca, bcac, cabc,
- cbbb, cbcb, ccac, ccba, ccbb, aaabc, aabcc, abaaa, abbab, abbca, abcab,
- acaab, acaac, acaca, acbab, accab, baaab, baccc, bbbab, bbcbc, bcacb,
- bcbba, bcbbb, bccab, bcccb, cabab, cabba, cabcc, cacac, cbabc, cbacc,
- cbbbb, cbbca, cbcba, ccaac, ccabc, ccbba, ccbca, cccab, aaabac, aaabba,
- aaacbc, aabaaa, aabbab, aabbbc, aacaac, aacbbb, aacbca, aaccab, aacccb,
- aacccc, abaaaa, ababab, ababba, abbaac, abbabc, abbacc, abbbcb, abcaaa,
- abcacc, abccbc, acaabc, acabab, acacab, acbbab, acbcaa, accaac, accbbc,
- accbca, acccba, bababc, babbca, babcab, babcac, babcbc, babccb, bacbaa,
- baccbb, bacccb, bbaaca, bbabac
- Regex: a[^ca]
- Pos:
- Neg: abb, bbc, abbb, acaa, acab, bbab, bbac, bbbc, caaa, cbbb, aaaab, aabcc,
- aacab, aacac, abaab, abcbc, acbba, acbca, accbb, accca, baaac, baabb,
- babaa, babcb, bbbab, bbbbb, bbbca, bbbcb, bbcaa, bbcca, bcaab, bcbaa,
- bcbab, bcbac, bcbba, caaaa, cabba, cabbb, cacbc, cbaaa, cbbab, cbbca,
- ccacc, ccccb, aaabaa, aaabca, aabacb, aabacc, aabbcb, aabcaa, aabcab,
- aacbac, abaacb, abacab, abacbc, abaccb, abbaba, abbbca, abccbc, acaabb,
- acabcb, acacaa, acacca, acbabc, acbcab, accabc, accacb, accbaa, accbba,
- accbca, acccbb, baaabc, baabaa, baabba, baacba, baacbb, babbaa, babbab,
- babbcb, babbcc, babcbc, bacabc, bacbac, bacbba, baccba, bbaaba, bbaccc,
- bbbcac, bbcbaa, bcacaa, bcbaca, bcbbaa, bcbcaa, bcbcac, bcbcca, bccacb,
- bccbbc, bcccbc, caaabb, caabbc, caabcc, caacba, cabaab, cabbba, cabcca,
- cacaac, cacbba, caccca, cbaacb, cbabcb, cbbbcc, cbbcac, cbcaac, cbcabc,
- cbcacc, cbcbbc, cbccba, ccaaac, ccaacc, ccacaa, ccacbb, ccacca, ccbbbb,
- ccbcaa, ccbcac, ccbccc, cccaaa, cccaba, cccacc, cccbcb, ccccba, aaaaaac,
- aaaaacb, aaaaacc, aaaacac, aaaaccb, aaababa, aaacaab, aaacacc, aaacbba,
- aaacbca, aaaccaa, aaacccc, aabaabc, aababaa, aababca, aabacab, aabacba,
- aabacbb, aabbaca, aabbbac, aabbbcc, aabbccc, aabcacb, aabccaa, aabccab,
- aabccba, aacaaab, aacaacb
- Regex: (([^ca]|a|c[^bc])(a|b)ε{2,}){2,3}
- Pos:
- Neg: b, cb
- Regex: ((a|b{2,4}){2})[^bac]b|a
- Pos:
- Neg: caa, cbb, abca, acaa, acab, acca, bbac, bbca, bcca, caaa, caab, ccab,
- aaaaa, aabbc, aacbc
- Regex: (c&a)|(b[^ca]{0,5})
- Pos: bbbbbbbbbb
- Neg: cb, aba, acb, acc, bab, bcb, cac, cbc, cca, abba, acba, baca, caac,
- caba, cabc, cbbb, cbbc, ccba, aaabc, aacac, abbcc, acaaa, baaab, baacb,
- bbbab, bcaab, bccac, caacc, cabaa, cabac, cacab, cacac, cacca, cbbbc,
- cbcab, cbcac, cbcbb, cbcbc, ccaba, ccabb, aaabaa, aaabab, aaabba, aaabcb
- Regex: ε[cb]&b|a{3,}
- Pos: bbbb, bbbbbbb, bbbbbbbbbbbb, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
- ...TRUNCATED BY DUNE...
- bcbb, caca, cbaa, cbab, aaaab, aaacb, aacca
- Regex: (c|a)(a|a)&[bac]|[^abc]a
- Pos:
- Neg: cc, acb, bac, cac, aaab, acab, baba, bbca, bcca, caca, ccaa, ccbb, ccbc,
- cccb, aaabc, aaacc, aabaa
- Regex: ((ab[acb][^cab]+){0,2})([abc]|(c&a*))
- Pos: a
- Neg: aab, acb, bcb, cca, ccb, aaac, aaca, aacb, abca, abcc, acab, baaa, baba,
- bcbc, caab, ccab, aaaaa, aaaba, ababc, abcba, acaba, acabb, acaca, acacb,
- acbbb, acccb, baaab, baabb, babaa, babcb, bacba, bbbac
- Regex: b&b{1}
- Pos:
- Neg: ab, bb, cac, ccb, aabb, acac, baaa, baba, bbac, bcab, bcac, aaaac,
- aabbb, aacba, abbcc, abcba, acaaa, acbba, acccb, baaac, baabc, babba,
- bacac, bacbb, bbaac, bbabc, bbcaa, bcbab, bcbac, caaaa, caaac, cabba,
- cabbc, cacac, cbbba, cbbcb, ccbba, ccccb, aaabca, aaacbc, aaaccc, aabbcc,
- aabcab, aabcac, aabcbc, aabccc, aacaba, aaccbc, abaaac, ababac, abacac,
- abacbc, abbcaa, abbcbb, abbccc, abcabb, abcbbc, acabaa, acbbca, accacb,
- baaaca, baabba, baacca, bababb, babacb, babbca, bacbbc, bbaaba, bbaaca,
- bbabca, bbacab, bbbbab, bbbbac, bbbbba, bbcaaa, bbcaca, bbcbca, bbccba,
- bbccca, bcacca, bcbbba, bcbcba, bccabc, bccbba, bcccba, bcccbb, caaaac,
- caabbc, caacab, cababb, cabbca, cacacc, cacbba, caccab, caccca, cbaaba,
- cbacba, cbacbc, cbbbcb, cbbcbb, cbcabb, cbcbab, cbcbac, cbccab, cbcccb,
- cbcccc, ccaaba, ccabca, ccacbb, ccaccc, ccbabc, ccbbbc, ccbcca, cccacc,
- cccbaa, ccccab, aaaacac, aaabacc, aaabbcc, aaabcaa, aaacbcb, aaacbcc,
- aabacca, aabbaaa, aabbaba, aabbacc, aabbbcb, aabcbaa
- Regex: a&b
- Pos:
- Neg: ac, cb, baa, aaaa, aaac, aabb, aaca, babc, bbaa, bbcb, caab, ccaa,
- aacca, aaccb, ababb, abbcb, abcbc, accac, acccb, baaba, baccc, bbbaa,
- bbcac, bcaac, bcabc, cabca, cacab, cacbb, cbaac, cbaca, cbbbb, cbcbb,
- cbcbc, ccacc, ccbac, ccbca, ccbcb, cccaa, cccbb, aaaacb, aaabca, aabaac,
- aabbaa, aabbbc, aabcba, aacaac, aacaba, aacbab, aacbbb, aaccba, ababbc,
- abacba, abbaab, abbaca, abbbab, abbbac, abbcac, abbcbc, abcabc, acaaac,
- acaacb, acabac, acacab, acaccc, acbabb, acbbca, acbcbc, accabc, accbca,
- baacbb, babacc, babbba, babbca, babccb, bacbaa, bacbcc, bbabca, bbbbab,
- bbbbbc, bbbcab, bbbcbc, bbcacc, bcaaba, bcbbcb, bcbcbb, bccaac, bccbac,
- bccbba, bccbbb, bccccb, caaacb, caabcb, caacac, caacbb, caaccc, cacaca,
- cacacb, cacacc, cacbbc, cacbca, cbaaca, cbabba, cbabbc, cbbbbc, cbbcac,
- cbbccb, cbcabc, cbcbca, ccaacb, ccabaa, ccacba, ccacca, ccbaba, ccbbbc,
- ccbcbb, cccaab, cccbaa, cccbcc, ccccab, ccccac, cccccb, aaaaaca, aaaaacb,
- aaaabba, aaaacaa, aaabacb, aaabacc, aaabbbb, aaabcaa, aaacabb, aaacabc,
- aaacbba, aababcc, aabacca, aabbabb, aabbbab, aabbbba, aabbcba
- Regex: (bε|[ab]a+)&(b[^b]|[ba][^ca]{3,})
- Pos:
- Neg: acb, baa, bba, caa, abbc, abca, abcc, baab, bcab, bcac, cbbc, cbcc,
- ccbc, aaaab, aaabb, aabca, aacaa, aacac, abaac, abbac, abbba, acabb, acacc,
- acbba, babac, babbb, bbaab, bbbca, bbbcb, bbcbb, bcbaa, bccbb, caaaa,
- caabc, caaca, cabaa, cabcc, cacac, cacba, cbbbb, ccacc, ccbca, cccac,
- cccbb, aaabba, aaacab, aababa, aabacc, aabbac, aacabc, aacaca, aacacb,
- aacbbc, aaccaa, aaccba, aaccbc, aacccb, abaaab, ababbb, abacab, abacba,
- abbabc, abbbab, abbcbb, abbcca, abbccc, abcaba, abcbbc, abcbca, abcbcc,
- acaabb, acaabc, acaacc, acabab, acbbba, acbbbb, accaba, accacc, accbcc,
- baaaaa, baaaac, baaaca, baabaa, baacaa, baacab, baacac, baacca, baaccb,
- babcab, babcbc, babcca, babccb, bacabc, bacbca, baccaa, bacccb, bbabbc,
- bbabca, bbacab, bbbbac, bbbcba, bbbcbb, bbcacc, bbcbaa, bbcbab, bbccca,
- bcaaab, bcabaa, bcabac, bcaccb, bcbbbc, bcbcca, bccbcc, caabaa, caacbc,
- cabbaa, cabbbc, cabcca, cacaac, cacaca, cacbab, cacbcc, cbaaab, cbacab,
- cbbaaa, cbbaba, cbbbba, cbbbcb, cbbcca, cbcaab, cbcabc, cbcbac, cbccac,
- cbcccb, ccabac, ccabca, ccbaab, ccbaac, ccbcaa, ccbccb, ccccbb, aaaaaac,
- aaaabbc, aaabbaa, aaacbca, aaaccbb, aababaa, aabacbc, aabbaaa, aabcaab,
- aabcaba, aabcbbb, aacabbb, aacbbcb, aaccabb, aacccac, aaccccc, abaaaca,
- abaacaa, abaaccb, abababc, ababbaa, ababbab, abaccbc, abacccc, abbaaab,
- abbaacb, abbabba, abbabbc, abbbaac, abbbacb, abbcabc, abbcacc, abcaacb,
- abcabca, abcacba, abcacca, abcbaab, abcbaca, abcbbaa, abcbbab, abcbcaa,
- abcbcbc, abccabb, abccacc, abccbba, acaaaac, acaaabb, acaabab, acaabac,
- acabbac, acabccb, acacaab, acaccbc, acacccc, acbaaba, acbaabc, acbaccc,
- acbbacb, acbbbaa, acbbbcb, acbcaac, acbcbba, acbcbcb, accacac, accbbcc,
- acccaab, acccacc, acccbac, acccbcc, baaaabc, baaabaa, baaabab, baaacbc
- Regex: [^cba]*
- Pos:
- Neg: aa, abc, baa, bac, cba, accb, bcab, aaabc, aabab, aabbb, aacbc, aacca,
- ababa, ababb, acacb, acacc, acbcb, accaa, baaac, baabb, baabc, baaca,
- baccb, bbbbb, bbcaa, bcabb, bccba, bccbc, cabab, cacaa, cbacb, cbacc,
- cbbab, cccab, aaaaaa, aaabab, aaabbb, aaacba, aaacbb, aabbbb, aabbbc,
- aabbcc, aabcaa, aabcca, aacbbc, aaccaa, abaabb, abaabc, abaacc, ababba,
- abcaab, abcabc, abcbca, acabbc, acbbba, acbbbc, accabb, baaaac, baaabc,
- baabaa, baabca, baaccb, babbba, babbbb, babccb, bacaab, bbaabb, bbabac,
- bbabcc, bbbcba, bbbccb, bbcabb, bbcaca, bbcbcc, bbccbc, bcaabc, bcabcb,
- bcbaaa, bcbabc, bcbacb, bcbcca, bccaba, bccacb, bccbac, caabbc, caacab,
- caacac, cabaaa, cababa, cabbab, cabbba, cabcaa, cabcac, cacbaa, cacbca,
- cacbcc, caccaa, cbaacc, cbabac, cbaccc, cbbcac, cbcaaa, cbcccb, ccaaaa,
- ccaaac, ccabca, ccacaa, ccaccb, ccaccc, ccbbba, ccbbcb, cccbac, cccbbb,
- aaaaacb, aaabbcb, aaacabc, aaacacc, aaacbba, aaacbca, aaaccba, aabaacb,
- aabaacc, aababbb, aababca, aabacbb, aabacca, aabaccb, aabbabb, aabbbab,
- aabbbbb, aabbbcb, aabcaab, aabccac, aacaacb, aacabab, aacabbb, aacabbc,
- aacacac, aacaccc, aacbaac, aacbcac
- Regex: ([^ab]&[acb])[ba]ba[^acb][ab][^acb]
- Pos:
- Neg: a, ac, bb, cc, aaa, abb, aacb, acbb, bbcc, bcaa, bcac, cabc, ccaa,
- aaaac, aacaa, abaaa, abbcb, abcba, abcbb, abccc, acabb, acbbc
- Regex: [^c]a(a&[^bca])+
- Pos:
- Neg: aba, aca, baa, bba, cba, aaba, aabb, aabc, acac, accc, baba, bccb, bccc,
- cacb, cbac, cbbb, cbcc, ccbb, aaaaa, aabaa, aabac, aacab, aacbb, aacbc,
- abacb, abbaa, abbab, abbac, abcaa, abccc, acbbc, accac, accba, baaba,
- baabb, baaca, bbacc, bbbac, bbbbc, bbbcb, bcabc, bcbca, bcbcc, bccac,
- bccca, bcccb, caaca, cabcb, cbacc, cbbbc, cbccb, ccaaa, ccacc, ccbaa,
- aaaacb, aaaacc, aaabaa, aaabbc, aabaaa, aabbba, aabbbb, aabcbb, aacaaa,
- aacbbb, aaccbb, abaaca, abacbb, abbaaa, abbaba, abbacc, abbbca, abcbcb,
- acabbb, acabcc, acacca, acbbab, acbbbb, accbbb, accbca, acccac, accccb,
- baaaba, bababa, bababb, babacc, babbab, babbbc, babcaa, bacabc, bacbaa,
- bacbab, bacccb, bbaaac, bbabca, bbabcb, bbbaaa, bbbaca, bbbbac, bbbcbb,
- bbcacb, bbcacc, bcaacc, bcabac, bcabbb, bcacbb, bcaccb, bcbaaa, bcbaba,
- bcbaca, bcbacc, bccaac, bccaba, bccbba, caabab, caabbc, caabcb, caacab,
- cabbba, cabbcb, cabcac, cacaca, cacacc, cacbaa, cbaaac, cbaacc, cbaccc,
- cbbaaa, cbbacb
- Regex: (b{1,4})[^ab]c
- Pos: bbbbcc
- Neg: bca, cac, cca, aaaa, aacb, acaa, baab, bbca, cbcb, aaaac, aaacb, aabaa,
- aabab, aacac, aacba, ababb, abccb, acbab, acbbb, baacb, babab, bbabb,
- bbbac, bbcba, bcaac, bccaa, bccab, bccba, caaca, cabac, cabbc, cacbc,
- cbaab, cbabc, cbbab, cbbba, ccaca, aaaacb, aaabac, aaacac, aaacba, aaaccb,
- aaaccc, aababc, aabacb, aabbab, aabbbc, aacabc, aacacc, ababca, abaccc,
- abbaca, abbccc, abcbaa, abcbac, acaabb, acabaa, acacbb, acbaaa, acbbbb,
- acbbbc, acbbcb, acbcab, acbcca, acbccb, baaacc, babbab, babcab, babcac,
- babcca, bacaaa, bacacb, bbaaba, bbaabb, bbabbb, bbacba, bbbaaa, bbbcba,
- bbcabc, bbcbca, bbccaa, bbccbb, bbccca, bcaaab, bcaacc
- Regex: ([abc]ε*)&(b[^ac]{3,}){2,5}
- Pos:
- Neg: ca, abc, baa, bcb, cab, aaba, aaca, acaa, acab, acbb, baaa, baab, babc,
- bbaa, bbab, bcac, caaa, caab, cacb, cbbb, cbca, aacaa, aacbc, aaccc, abaab,
- abbca, abbcc, acabb, acbac, acbbb, baacb, babaa, bacbc, bbbaa, bbbcb,
- bcbca, cacaa, cbaab, cbabc, cbcaa, cbccb, ccaab, ccbca, cccca, aaaaaa,
- aaaaab, aaabbb, aaacab, aaacac, aabbcb, aacaab, aacacb, aacccb, aacccc,
- abaaaa, abbaaa, abbabb, abbbbc, abbbcc, abbcca, abcaba, abcaca, abcbac,
- abccbc, acabca, acabcb, acacbb, acacbc
- Regex: [ac]|[^ab]&b|c
- Pos:
- Neg: ba, cc, bac, bcc, ccc, aaac, acaa, baaa, bbba, bcac, bcba, bccc, caab,
- cacb, cbac, ccab, cccc, aaaaa, aacba, aaccb, abaac, ababb, abcaa, acaab,
- acbaa, acbba, acbbb, accbb, baacc, bacaa, bacbc, baccc, bcabc, bcbbc,
- bccbb, bcccb, cabaa, cabab, cacbc, cbabb, cbbbb, cbbcb, cbccc, ccaaa,
- ccaba, ccabc, ccbcb, cccab, cccbb, aaaaba
- Regex: [cab]b[bac]
- Pos:
- Neg: bac, bbab, bbcb, cacb, cbaa, cbac, ccbc, aaabb, aacbc, abbca, abcab,
- abccc, acaca, acacc, acbcb, acbcc, accab, accbc, baaac, baabb, baabc,
- baccb, bbaba, bbabc, bbaca, bbbba, bcaaa, bccbb, caaaa, caacb, cabca,
- cacac, cbaab, ccabc, ccbbb, ccbbc, ccbca, aaaaaa, aaaacb, aaabba, aaabbc,
- aaacbc, aacaab, aacacc, aacccc, abaaab, abacbb, abbccb, abccbb, acaaba,
- acabbc, acabcc, acacba, acbabb, acbabc, acbacc, acbbaa, acbbcc, acbcba,
- baaaaa, baabac, bababa, bababc, babacc, babbac, babbba, babbbc, babcac,
- bacaab, bacacc, baccaa, bbabcc, bbacbb, bbbaab, bbbacb, bbcaab, bbcacb,
- bbcbaa, bbccac, bbcccc, bcabaa, bcacab, bcacca, bcbbaa
- Regex: ((a|[^cb])([^bca]|a){1}){2,}
- Pos:
- Neg: ba, bb, bba, bbc, acba, bbac, bbbb, caab, cabc, cacc, cbbb, cbbc, ccac,
- ccbc, cccc, aaaac, aacbc, abaca, abbbb, abcca, acaaa, acbca, baaca, baacb,
- babac, babba, babcb, bacac, bbaca, bbbbb, bbcaa, bcbbc, bcbcb, caaaa, caaca
- Regex: ([ab][ba]{3,})&(c|b+)
- Pos:
- Neg: c, bb, bc, abb, acb, baa, bac, bbc, aaac, aabc, abac, abbb, accc, baca,
- bbaa, bbac, bbcb, bcca, cbac, ccca
- Regex: a
- Pos:
- Neg: aa, aaa, acc, bbc, cbb, aacb, abab, abca, bbaa, bbbb, bcbc, bccc, cabc,
- cacb, cbab, ccbb, ccca, aaaba, aabab, aabbb, aabcc, aacba, aacbb, aaccc,
- abaab, abbaa, abbac, abbbc, abbcb, abcab, abcac, abcba, abcbc, acbaa,
- acbbc, acbcc, acccb, baaba, bbaca, bbbab, bbcba, bcaab, bcbcc, caaba,
- cabba, cabbc, cabcc, cbbab, cbbbc, ccbaa, ccbcb, ccbcc, aaaaac, aaaaca,
- aaabac, aaacca, aabbbb, aabcbb, aaccaa, abaabc, ababaa, ababac, ababba,
- abbbaa, abbbab, abbcbc, abcaca, abcbab, abccab, abccba, abccbb, acaacc,
- acabaa, acacbb, acbbaa, acbbbc, acbcbc, accaaa, accaab, accbbb, acccca,
- baabaa, baabac, babaac, babbab, babbbc, babbcb, bacacc, bbaaba, bbabba,
- bbabbb, bbabbc, bbacac, bbacbc, bbbaca, bbbacb
- Regex: ((cc{2,})&c[^a])(c|b)(c|[^b])
- Pos:
- Neg: ab, cc, aab, acb, bba, bcb, cca, aabc, aacc, abaa, abba, baab, bbab,
- bcbb, bcca, caab, caac, cbcc, ccab, ccba, aaaab, aaaca, aabbb
- Regex: (c|a|[^cab]b{0,1})&bb([bca]&[^ba])
- Pos:
- Neg: aab, aac, abb, baa, bbc, bcb, abaa, abab, abca, abcc, baab, bcbc, cbbc,
- cccb, aabbb, aacaa, aacbc, abcab, acaab, acbaa, acbca, accac, accbb, bbaab,
- bbabb, bbbcb, bccaa, bccac, caaac, cbacc, ccaaa, ccacb, ccbaa, cccca,
- aaaaab, aaacba, aabaaa, aabbab, aabbca, aabbcc, aabcab, aabcba, aabcbb,
- aabcca, aacaaa, abaabc, abacca, abaccb, abbbaa, abbbcb, abbcaa, abbcbc,
- abcabc, abcaca, abccac, acaabb, acabbb, acbacb, acbbbb, acbbca, acbcac,
- acbccc, accaaa, accccb, baabba, baabcc, baacbb, baaccb, bababb, babcbb,
- bacaaa, bacbac, baccaa, baccba, bbaabc, bbabab, bbacaa, bbacca, bbaccb,
- bbaccc, bbbaaa, bbbabc, bbbbcc, bbbcab, bbcaab, bbcabb, bbcabc, bbcbcc,
- bbccaa, bbccca, bcabac, bcabba, bcabbb, bcabbc, bcacaa, bcaccc, bcbaac,
- bcbabb, bccacc, bccbca, caacaa, caacbb, caaccb, cacbac, caccbb, cbaacb,
- cbacba, cbbbba, cbbbcc, cbbcca, cbcaaa, cbcbbb, cbcbca, cbccac, cbccbc,
- ccaaab, ccaabc, ccacac, ccbaab, ccbaba, ccbacc, ccbbac, ccbbcc, ccbcac,
- ccbcca, cccbba, cccbca, aaabaaa, aaababb, aaabbac, aaabcba, aaabcca,
- aaacacc, aaaccab, aaaccac, aaaccba, aaaccbb, aabaacc, aabacba, aabacbb,
- aabbbba, aabbbbc, aabbbcc, aabcabc, aabcbcc, aacaaaa, aacaabb, aacacaa,
- aacbabc, aacbbbb, aacbbca, aacbccb, aaccacb, aaccbca, abaabab, abaabbb,
- abacbca, abacccc, abbaaab, abbaaca, abbabbc, abbacaa, abbacab, abbbabc,
- abbbcac, abbbcbb, abbbcbc, abbcaac, abbcbba, abbcbbb, abbccac, abbccca,
- abcaaac, abcabaa, abcacbc, abcbabc, abcbbba, abcbcbb, abccbcc, abcccab,
- abcccca, abccccc, acaabac, acaacaa, acaacbb, acababa, acababb, acabaca,
- acabbcc, acabcba, acabcca, acacaab, acacaba, acbacbb, acbbacb, acbbcaa,
- acbcabc, acbcbca, acbccca, accaabb, accaabc, accacca, accbaca, acccabc,
- acccacc, acccbbb, acccbca, acccbcc, accccab, acccccb, baaaaaa, baaaabb,
- baaaabc, baaaccc, baababa, baabbab, baabbbb, baabcba, baacaca, baacbab,
- baacbbb, bababcb, babbacc, babbbab, babbbbc, babbbcb, babbcca, babbccb,
- babcaac, babcbaa, bacbaab, bacbaac, bacbbcb, baccaac, baccbbc, bbaaabc,
- bbaabbb, bbaacab, bbaacac, bbaacba, bbababa, bbababc, bbabbbb, bbabcca,
- bbabccc, bbacaac, bbacacb, bbacbcb, bbbaaac, bbbaaba, bbbaabc, bbbacaa,
- bbbbaba, bbbbabb, bbbbcbb, bbbcaac, bbbcacb, bbbccac, bbbccca, bbcabab
- Regex: b
- Pos:
- Neg: ba, acc, bcc, accc, babb, bbaa, bbba, bcab, bcac, bcbc, cbbb, ccbc,
- cccc, aaacc, aabab, aabcc, aacbb, ababc, abcca, acaca, accab, accbc, acccc,
- babcb, babcc, bacbc, baccc, bbaca, bbbbc, bbbcb, bbcab, bbcca, bbccc,
- bcbcb, cabaa, cabab, cacac, cacca, cbacc, cbbba, cbbcb, cbcab, ccbab,
- ccccc, aaabbb, aabacb, aacacb, abaabb, ababaa, ababba, ababca, abacab,
- abacbc, abbcbc, abcacb, abcacc, abcbaa, abcbac, abccba, abccbb, abccbc,
- acaaaa, acaaca, acabca, acbaaa, acbaba, acbacb, accbbb, accbcb, acccac,
- acccba, baabcb, baacca, babaac, babaca, babbba, bacccb, bbaabb, bbacbb,
- bbaccc, bbbaaa, bbbbab, bbbbac, bbbcab, bbcaba, bbcabb, bbcacb, bbcacc,
- bbcbba, bbcbbc, bbccbb, bcaccb, bcbaaa, bcbabc, bcbbba, bcbccb, bccaaa,
- bccacc, bccbcb, bcccbc, caaaac, caabaa, cabaab, cabacc, cabcba, cacaca,
- cbaacb, cbacba, cbbbac, cbbbbb, cbbbcc, cbcbab, cbccab, ccbabb, ccbacb,
- ccbbaa, ccbbba, ccbbbb, ccbbbc, ccbcac, ccbccc, cccaca, aaaaaaa, aaaaabb,
- aaaabaa, aaaabbb, aaaabbc, aaaabca, aaaacac, aaaaccc, aaabaac, aaacabb,
- aaaccac, aababac, aababbb, aababcb, aabbaab, aabbacc, aabbbab, aabbbca,
- aabcaaa, aabcccb, aabcccc, aacabcc, aacbacb, aacbbab, aacbbbc, aaccaca,
- abaaaba, abaabcc, abaacac, abaaccc, ababaaa, ababbca, abacaba, abacbbb,
- abacbbc, abacbca, abacccb, abacccc, abbabbb, abbaccb, abbaccc, abbbaac,
- abbbbaa, abbcabc, abbcbaa, abbcbbc, abbccac, abcaaab, abcbabb, abcbcac,
- abcbcba, abccacb, abcccca, acaaabc, acaaacb, acaacbc, acabaaa, acabacc,
- acabbaa, acabbba, acabcba, acabcbb, acacaac, acacbab, acacbcc, acbacac,
- acbacbc, acbaccc, acbbbbc, accabaa, accabcc, accaccc, accbaac, accbbcb,
- accbccc, acccaca, accccab, accccac, baaaabc, baaacca, baaaccc, baabbcc,
- baabcca, baacabb, baacbca, baaccaa, bababcc, babacac, babbbac, babbcab,
- babbccc, babcaab, babcacb, bacaaac, bacaaba, bacabbc, bacacab, bacacca,
- bacbaaa, bacbbca, bacbcac, baccabc, baccacc, baccbaa, bbaaabc, bbaabcb,
- bbaacaa, bbaacbb, bbaacca, bbabaaa, bbababa, bbabacc, bbabbaa, bbabbbc,
- bbabcbc, bbabcca, bbabccb, bbacabc, bbacbca, bbbaaaa, bbbaaca, bbbabaa,
- bbbabbb, bbbaccb, bbbbabb, bbbbbbc, bbbbbcb, bbbbcaa, bbbbcbc, bbbbccc,
- bbbcaab, bbbcaac, bbbcbaa, bbbccbc, bbbcccb, bbbcccc, bbcaacb, bbcabca,
- bbcbaab, bbcbbab, bbcbbbb, bbcbcab, bbcbcca, bbccbbb, bcaacba, bcaaccb,
- bcababb, bcabacb, bcacabc, bcacaca, bcacbac, bcbabac, bcbabba, bcbabca,
- bcbacaa, bcbbaba, bcbbbac, bcbbbbc, bcbbbca, bcbbcac, bcbbcba, bcbcaba,
- bcbcbaa, bcbcbab, bcbcbac, bcbccbc, bccaaac, bccaabb, bccabab, bccbaac,
- bccbacb, bccbbaa, bccbbab, bccbcba, bccbcca, bcccccb, bcccccc, caaabcb,
- caaacac, caaaccc, caabaaa, caabbac, caaccab, cabacab, cabbaaa, cabbaac,
- cabbbaa, cabbbab, cabcaaa, cabcacb, cacaaac, cacaaba, cacacca, cacbaaa,
- cacbccc, caccbba, caccbcb, cacccbb, caccccc, cbaabac, cbaaccc, cbabaca,
- cbabccc, cbacaac, cbacaca, cbaccbc, cbbacca, cbbaccb, cbbaccc, cbbbbbc,
- cbbbccb, cbbcaba, cbbcbac, cbbccca, cbbcccc, cbcaaab, cbcabca, cbcaccb,
- cbcbabc, cbcbcac, cbcbcbc, cbcbcca, cbccacb, cbccacc, ccaaabb, ccaaabc,
- ccaabba, ccaabca, ccaabcc, ccababc, ccabbba, ccacaac, ccaccab, ccbabab,
- ccbabcc, ccbacbb, ccbbbbc, ccbbcac, ccbbcbc, ccbcaab, ccbcabc, ccbcbab,
- ccbccca, ccbcccc, cccaaac, cccabaa, cccabbb, cccabcb, ccccaba, ccccabb,
- ccccbac, cccccaa, cccccba, cccccca, aaaaaaca, aaaaabac, aaaacabb, aaaacccb,
- aaababaa, aaababba, aaabacbc, aaabcaac, aaabcabb, aaabcbac, aaabcbca,
- aaabccba, aaabccbc, aaacaaac, aaacaabb, aaacabab, aaacacab, aaacacbb,
- aaacacbc, aaacbcca, aaaccaaa, aaaccaba, aaaccbba, aaaccbcb, aaacccaa,
- aabaaaac, aabaaabb, aabaabaa, aabaabac, aabaabba, aabaacba, aababaac,
- aababacc, aababcab, aabaccba, aabbabba, aabbabbb, aabbacaa, aabbacac,
- aabbbabb, aabbbabc, aabbbbcb, aabbbcbb, aabbcbaa, aabbcbbb, aabbcbca,
- aabcabaa, aabcbabb, aabccaaa, aabccccc, aacaabab, aacaabbb, aacabaac,
- aacabbaa, aacabbca, aacabcac, aacabcba, aacacabb, aacaccab, aacbaaca,
- aacbabaa, aacbabca
- Regex: (a|c)(a|[bca]){2,4}
- Pos: acab, cccb, aaaaac, aaabaa, aaaccc, aacaac, aacacb, aacccb, ababca,
- abacaa, abcbcc, acaaac, acabab, accacc, accbab, caaaac, caabac, caacab,
- caaccc, cbaacc, cbabca, cbaccc, cbcaac
- Neg: b, aa, aba, abb, cbb, cca, bbbc, ccbb, aaabb, aaabc
- Regex: [cba]ac[^acb](b[bac]&bc)
- Pos:
- Neg: b, c, ac, bc, bca, abcc, accc, baaa, baab, bcaa, bcba, cacb, cbaa, cbca,
- cbcb, ccab, aaaab, aabaa, aabac, aacbc, ababa, abbba, abbca, abbcb, abcaa,
- acbaa, acbcc, baccb, bbaac, bbabb, bbbab, bbbcc, bcaab, bcacc, bcbbc,
- bccac, cacaa, cacbc, cbabb, cbacb, cbbaa, cbbac, cbbca, aaaaab, aabcba,
- aabccb, aacaac, aacbcc, aaccbb, aaccbc, abaabb, abbbab, abbbba, abbbca,
- abbcaa, abbcba, abbccc, abcabb, abccac, abccbb, abccbc, abccca, acabbb,
- acaccb, acbaab, acbaac, acbbac, acbbca, acbcbb, accaba, accabc, accbbc,
- accbcc, baaaba, baabaa, bababa, bababc, babbac, babcba, bacabb, bbaaac,
- bbabca, bbabcb, bbbaba, bbbaca, bbbbac, bbbbba, bbcbaa, bbcbab, bbccca,
- bcaaca, bcaacb, bcaacc, bcacac, bcacba, bcaccc, bcbbca, bcbcba, bcbccc,
- bccaaa, bccabb, bccbac, bcccbb, caaaab, caabaa, caabba, caabcb, caacaa,
- caacba, cabbca, cabcba, cabcbc, cacaab, cacbab, cacbac, cacbba, cacbcc,
- cbaabc, cbabcc, cbacab, cbbaba, cbbacb, cbbbbb, cbbcab, cbcaaa, cbcaca,
- cbcbaa, ccaaac, ccaaba, ccaacb, ccacbc, ccbaab, ccbbcb, cccaaa
- Regex: a|ε&((c{3,4}){3})
- Pos:
- Neg: acb, acc, bcc, cbc
- Regex: c(c|c|b{2})
- Pos:
- Neg: a, bc, acb, bbc, aaaa, abba, acaa
- Regex: ab(b|c*)([cab]ε&(c|c{3,5}))
- Pos:
- Neg: aba, abb, abc, acc, baa, cba, aabb, aacb, acba, accc, bacb, bbbc, caab,
- cacb, cbbb, ccaa, ccbb, aaaaa, aacca, aaccb
- Regex: ((c{2,3})|[ca][bac])((b&c)|[bc]c)
- Pos:
- Neg: b, ba, ca, cc, baa, cac, abca, abcb, acbb, baab, babc, cacb, cbbb, ccca,
- aaaaa, aacca, abacb, abcca, acabb, acbaa, accab, accbc, baaaa, baaac,
- babca, bbacc, bbbcc, bbcab, bcccc, caaac, caabc, caaca, cabcc, cacba,
- cbaac, cbbab, cbbbc, cbbca, cbcaa, cbcac, ccabb, ccbbb, aaabac, aaabcc,
- aabaac, aabbaa, aabbcb, aabcaa, aacaaa, aacbaa, aacbba, abaaaa, ababcc,
- abacac, abacbc, abaccb, abaccc, abbaaa, abbccb, abcacb, abcbcc, abccba,
- acabca, acacab, acacbc, acbbac, accbac, acccbc, accccb, baacba, baacbb,
- baacca, bacabc, bacbac, bacbbb, baccbb, bbaaac, bbaaca, bbabbb, bbabca,
- bbacaa, bbbaba, bbbbca, bbcaaa
- Regex: (b&[acb]{2,})(cε{2,})
- Pos: bbbcccc, bbccccc, bbbbbccc, bbbccccc, bbbbbbbbcccc, bbccccccccccc,
- bbbbbbbbbbcccc, bbbbbbbbbccccc, bbbbcccccccccc, bbbbbbbbccccccc,
- bbbbbbbbbbccccccc, bbbbbbbbbcccccccc, bbbbbbbcccccccccc, bbccccccccccccccc,
- bbbbbbbbbbbbbbcccc, bbbbbbbbbbbbbbbcccc, bbbbbbbbbbbbbcccccc,
- bbbbbbbbbbbcccccccc, bbbbbbbbccccccccccc, bbbbbbbcccccccccccc,
- bbbbbbbccccccccccccc, bbbbbbbbbbbbbbbcccccc, bbbbbbbbbbbbbbbbbccccc,
- bbbbbbbccccccccccccccc, bbbbbbbbbbbbbbbbbbccccc, bbbbbbbbbbbbbbbcccccccc,
- bbbbbbbbbbbbbcccccccccc, bbbbbbbbccccccccccccccc, bbbbbbccccccccccccccccc,
- bbbbbbbbbbbbbbbbbbbbcccc, bbbbbbbbbbcccccccccccccc,
- bbbbbbbbbccccccccccccccc, bbbbbbcccccccccccccccccc,
- bbbbbbbbbbbbbbbbbbbbbbbcc, bbbbbbbbbbbbbbbbbbbbbbbccc,
- bbbbbbbbbbbbbccccccccccccc, bbbbbbbbbbbbbbbbbbbbbbbbbcc
- Neg: ba, aab, abc, aca, acc, baa, ccc, aabb, aabc, aacb, abab, acaa, acac,
- baab, bacb, bacc, bbbc, bcba, bcbc, bccb, cbca, aaabc, aabab, aabba, aacbc,
- aaccc, ababa, ababc, abbab, abcba, acaac, acabc, acacb, acbaa, acbbb,
- acbcb, acbcc, accca, baacb, babba, bacab, bcabb, bcccc, caaba, cacba,
- cacbb, cacca, cbaca, cbacc, cbbba, cbcbc, cbccb, ccaac, ccabb, cccbc,
- aaaabc, aaaaca, aaabac, aaacbb, aaaccc, aabbcc, aabcac, aacaaa, aacbba,
- aaccab, abacbc, abbacc, abbcba, abcabc, abcacc, abccca, acaacc, acabcc,
- acacaa, acacbc, acbacc, acbbbc, acbcba, acbccc, accacc, accbbb, accbcc,
- baacbb, baacbc, bababb, babaca, babbca, babbcc, babcbc, bacacb, bacacc,
- bacbba, bbaabb, bbabac, bbabbb, bbbacb, bbbcac, bbbcca, bbcabc, bbcbaa,
- bbcbca, bbcbcc, bcaaca, bcacab, bcbbaa, bcbcca, bccaab, bccacc, bcccba,
- cabaab, cababb, cabcbc, cacabc, cacaca, caccbc, caccca, cbaaab, cbaaca,
- cbaacb, cbabac, cbabbb, cbabcc, cbbbaa, cbbbcb, cbbccb, cbcbac, cbcbbb,
- cbcbca, cbccbc, cbcccb, ccabba, ccabcc, ccacaa, ccacbc, ccbacc, ccbbbb,
- ccbcba, ccbcbc, cccabc, cccbcc, aaaaaac, aaaaabc, aaaabbc, aaaabcb,
- aaaacca, aaaaccc, aaababa, aaabcab, aaabcac, aaacbcb, aaaccba, aabaaaa,
- aabacba, aabacbc, aabbaab, aabbacb, aabbcac, aabbcbb, aabcaca, aabcbba,
- aabcbcc, aabccba, aabccca, aabcccc, aacabac, aacabca, aacabcc, aacacbb,
- aacbbab, aacbbca, aacbcab, aacbcca, aaccbbc, aacccba, abaaabb, abaaaca,
- abaaacb, abaabac, ababbba, ababbbc, ababbca, ababbcb, abacaba, abacbbb,
- abacbca, abaccca, abbaaac, abbacaa, abbbabb, abbbbab, abbcbab, abbcbbc,
- abcaaab, abcaabb, abcaaca, abcabba, abcabca, abcbaca, abcbbca, abcbbcb,
- abccabb, abcccac, abccccc, acaaabc, acaaacc, acaabac, acaacaa, acabbbc,
- acabcac, acabcca, acacbba, acaccab, acbaacb, acbaacc, acbbaac, acbbabc,
- acbbbcb, acbbbcc, acbcabc, acbcbca, accaaac, accaabc, accabbc, accbcca,
- accccbc, baaabac, baaacac, baaacba, baaaccc, baabcca, baacaac, baacacc,
- baacccb, baacccc, bababca, bababcc, babacbb, babbbaa, babbccc, babcbcb,
- babcccb, bacaaaa, bacabac, bacabcb, bacacac, bacbaac, bacbacc, bacbcba,
- bacbcca, baccbcc, bacccbc, bbaaabc, bbaabaa, bbaabac, bbaaccc, bbabaac,
- bbabbac, bbacaca, bbaccba, bbaccbc, bbaccca, bbacccc, bbbaaac, bbbabaa,
- bbbabcc, bbbacbb, bbbbcca, bbbcaaa, bbbcbac, bbbcbca, bbcabcb, bbcabcc,
- bbcbaca, bbcbcab, bbccabc, bbccbab, bcaaabb, bcaabac, bcaacac, bcabaaa,
- bcababb, bcabacc, bcabcaa, bcabcab, bcabcbb, bcacabb, bcacacb, bcacbac,
- bcacbba, bcacccb, bcbaaba, bcbabbb, bcbabcc, bcbacba, bcbbabb, bcbbccb,
- bcbcaaa, bcbcaba, bcbcbbb, bcbcbca, bcbccab, bcbcccb, bccbbaa, bccbcbc,
- bcccaab, bcccacb, bcccbbb, bcccbcb, bccccaa, caaacac, caaaccb, caabacc,
- caabbbc, caabcab, caacabb, caaccab, caaccbb, cabaaca, cababba, cabacca,
- cabbaaa, cabbaca, cabcaca, cabcbbc, cacacac, cacbaab, cacbbcb, cacbcca,
- cacbccb, caccaaa, caccacb, caccacc, cacccba, cbaaacb, cbaabac, cbaabba,
- cbaabbc, cbabaca, cbabacb, cbabbab, cbabbca, cbabcaa, cbacaaa, cbacabb,
- cbacabc, cbacbca, cbaccba, cbbaccb, cbbbaca, cbbbbac, cbbbbba, cbbbcbb,
- cbbbccb, cbbcaac, cbbccbb, cbbccbc, cbcabbc, cbcacaa, cbcacbb, cbcbbcc,
- cbcbcba, cbccabb, cbccabc, cbccaca, cbccbba, ccaacab, ccaacba, ccababb,
- ccababc, ccabacb, ccabcac, ccabcbc, ccacabc, ccacacc, ccacbab, ccbaaab,
- ccbaaba, ccbaacb, ccbabac, ccbacac, ccbcacc, ccbcbab, ccbccab, ccbccac,
- cccabbc, cccacbb, cccbaca, cccbacc, cccbbaa, cccbbab, cccbbba, cccbcaa,
- cccbcab, ccccabb, ccccbbc, cccccab, cccccac, cccccbc, aaaaabcb, aaaabbac,
- aaaabbbb, aaaabbbc, aaaabbcc, aaaacabb, aaaacbca, aaabaacb, aaababac,
- aaabaccb, aaabbabc, aaabbacc, aaabbbbb, aaabbcbb, aaabcabb, aaabcbab,
- aaabcbba, aaabcbca, aaacabac, aaacaccb, aaacaccc, aaacbacb, aaacbbbc,
- aaaccabb, aaaccacc, aaaccbcc, aaacccba, aabaaaab, aabaaaca, aabaabba,
- aabaacbb, aabababa, aababbca, aababbcc, aababcba, aabacabc, aabbaaaa,
- aabbaaca, aabbabaa, aabbabab, aabbacab, aabbbaab, aabbbbba, aabbbcba,
- aabbbcbc, aabcaaaa, aabcabbb, aabcacab, aabcbbab, aabcbcba, aabcbcca,
- aabccaaa, aabccaba, aabccccc, aacaaaac, aacaabaa, aacaabba, aacaabbc,
- aacaacac, aacaacca, aacabacb, aacabbab, aacabbcc, aacabcbc, aacabccb,
- aacacacb, aacacbba, aacacbbb, aacaccca, aacacccc, aacbaaba, aacbacab,
- aacbacbc, aacbacca, aacbbaca, aacbccaa, aacbccca, aaccaabc, aaccabaa,
- aaccabcb, aaccacac, aaccbaab, aaccbaba, aacccaca, aacccbaa, aacccbcc,
- aaccccaa, aaccccab, abaaaaca, abaaaacb, abaaabbc, abaacaba, abaacabc,
- abaacacc, ababaabc, abababaa, abababca, abababcc, ababacab
- Regex: ([ab]ε&bε)[^abc][^cb]([^abc]|c)
- Pos:
- Neg: b, aa, cb, aaa, bba, aaaa, aaab, abab, abac, acac, acba, baab, bbab,
- bbcb, bcab, cbaa, cbcb, aaaaa, aabca, aacca, abbab, acaca, acbac, acbbb,
- acbcb, accab, accba, accbb, accca, acccb, baaca, baacc, bbacb, bbbaa,
- bbbba, bbbbc, bbcca, bbccb, bcacb, bccaa, bccab, bccac, bccbc, caabb,
- cabab, cabca, cacbb, cacbc
- Regex: ((c|[cba])[^bca][acb]+)a
- Pos:
- Neg: c, ab, bcc, ccb, aaca, abba, acac, acba, acbb, baac, bbbc, bbca, cacb,
- cbca, aaaac, aaacc, aabcb, abbca, abbcb, abbcc, abcac, acabc, acbaa, accbb,
- acccb, babaa, babba, bbbaa, bbbab, bbcbc, bcacc, bccca, cbacb, cbbaa,
- ccacb, ccbab, ccbac, ccbbb, ccbbc, aaaaab, aaaaba, aaaabc, aaacba, aabbba,
- aabbbb, aacaca, aaccaa, aacccc, abaaba, abaabb, ababaa, ababab, ababcb,
- ababcc, abacbb, abbaab, abcbaa, abcbca, abccca, acabab, acacaa, acacab,
- acbaaa, accaba, accabb
- Regex: ccbε((a&c{2,4})*)
- Pos:
- Neg: acb, bca, cac, aaab, abca
- Regex: [^abc](b|[^abc])((b&[^cab])|b[^ba])
- Pos:
- Neg: bca, aaac, abcc, acba, baaa, cacc, ccca, aabcb, aacac, aacba, abaca,
- abbcb, abccb, acbac, acbca, acbcc, accab, baabb, bacbb, bbaac, bbccb,
- bcaab, bccaa
- Regex: (a|b)b[ba]([^abc]|a|([^cba]{2,5})){3,5}
- Pos:
- Neg: ba, aab, acc, bca, ccc, aaaa, aaab, abaa, abab, abac, acbc, acca, accb,
- baaa, bbba, bcac, cacc, ccbc, ccca, aaaba, aaabc, aacaa, acaaa, acaab,
- acbbc, accaa, accab, acccb, baaba, babaa, babbb, bbabb, bbbab, bbbbc,
- bbbcb, bbcaa, bbcba, bbccb, bcacb, bcbbb, bccab, caaab, caaac, cacab,
- cacba, cbaba, cbbab, cbbac, cbbcc, cbcba
- Regex: cc
- Pos:
- Neg: ac, bc, aac, bba, bbc, bca, bcb, caa, abcb, accc, babb, babc, bbac,
- cabb, cbbc, cbca, cbcc, aaaaa, aabab, aabcb, aacab, aaccc, abaca, abbaa,
- abcab, abcbb, acacb, acbbb, baabb, babba, baccb, bbcac, bcaab, bcaba,
- bcbba, bcbbc, caacc, cabcc, cacba, cacca, cbaba, cbaca, cbbaa, cbbbc,
- cbbcb, cbcac, cbcca, cccca, aaaabc, aaabba
- Regex: ([acb]&c)|[ca]c&(a|c{2,})εb
- Pos:
- Neg: ab, aaa, bba, bca
- Regex: ([^ba]b&c|b)c
- Pos:
- Neg: bac, cbb, aabc, abac, accb, bcaa, caaa, cacb, aaacb, aacbc, aaccc,
- abacc, abbba, abbbc, abcbc, acaaa, acbab, acbca, accbb, accbc, baaaa,
- babaa, babba, bbbaa, bbbbc, bbbcc, bbcba, bcaac, bcacb, bcbac, bcbbb,
- bcbcc, caaab, caaca, cabca, cacbb, cacca, cbbaa, cbbbc, cbbca, cbcac,
- cbcbc, cbccc, ccacc, ccbac, cccab, aaaacc, aaabbc, aaacbb, aabaaa, aabbab,
- aabcbc, aabccb, aacaba, aacbab, aacbcb, abaaac, abaabb, abaabc, ababab,
- ababbc, abacaa, abacba, abbabc, abbcca, abcbac, abcbba, abcbbb, abcbcb,
- abccba, abcccc, acaaac, acabba, acabca, acabcb, acbcaa, accaba, accbab,
- accbba, accccb, baaaab, baaacb, baabaa, baabbb, baacbb
- Regex: ε[^cba]
- Pos:
- Neg: aa, aaab, aaac, abca, acab, acbc, baab, cabc, cbab, cbcb, aaabb, aaaca,
- aabcb, aacaa, aacbc, abaaa, abbba, abcba, abccb, acacb, acbba, acbcb,
- acbcc, accba, babbb, babca, bbaba, bbacb, bbacc, bcbcb, bccba, caaab,
- caaac, cabca, cbabb, cbbba, cbcab, ccaaa, ccabc, cccac, cccca, aaaaab,
- aaaabb, aaaabc, aaaaca, aaacab, aaacac, aabaca, aabacb, aabacc, aabcaa,
- aacaca, aacacc, aacccc, abaaac, abaaca, ababbb, abacba, abbabc, abbbbc,
- abbbcc, abbcab, abcacc, acaabb, acaaca, acabbb, acabcb, acbaaa, acbbbb,
- accacc, acccac, acccca, baaaca, baaacb, baabab, baabbb, baacab, babbbc,
- babbca, babcaa, babcba, bacbca, baccac, bbabac, bbabcc, bbacab, bbbaba,
- bbbbab, bbbcbc, bbbcca, bbcbcc, bcaabb, bcaacc, bcacbc, bcbaaa, bcbcaa,
- bcbcab, bccbca, bcccab, bcccbb, caaaaa, caabbb, caaccc, cabcbb, cabccb,
- cacaac, caccab, cbaabc, cbaaca, cbaacb, cbbabc, cbbccb, cbccaa, cbccca,
- ccaabb, ccabab, ccacca, ccbaab, ccbacb, ccbcbc, ccbccb, cccaca, cccacb,
- ccccba, aaaaabb, aaabcab, aaabcca, aaacbac, aaacbba, aaaccab, aaaccac,
- aababab, aabcacc, aabcbbb, aabcbcb, aacabaa, aacaccb, aacbaac, aacbabc,
- aacbbac, aacbccb, aacbccc, aaccaab, aaccabb, aacccbb, abaaaac, abaaaba,
- abaabbb, abaabcb, abaacbb, abababa, ababcba, abacbbc, abacbcc, abaccba,
- abaccbb, abacccc, abbaaab, abbabab, abbabba, abbacbc, abbbaaa, abbbbbc,
- abbbcbb, abbcaac, abbcaba, abbcaca, abbcbaa, abbccbb, abcaacc, abcabab,
- abcabcb, abcaccb, abcbabb, abcbbcc, abcbccb, abcbccc, abccaca, abccbac,
- abccbbb, abccbca, acaabaa, acaacab
- Regex: (c{2,})(cb&a&[^ba])
- Pos:
- Neg: acb, aaba, baaa, baac, bbab, bbca, ccab, ccbc, aacca, aaccb, abbab,
- abbbb, acabb, acbcb, acccc, babab, bbaab
- Regex: c
- Pos:
- Neg: a, cb, bba, cbc, aaac, aacb, acaa, acba, acbc, bacc, bbbb, bcba, ccab,
- ccac, aaaab, aacab, aacba, abbbb, acaba, acbac, acbcb, accbb, baccc, bbabb,
- bbacc, bbbbb, bbbbc, bbbcb, bbcaa, bbcba, bbccb, bcabb, caaca, cacbc,
- cbbba, cbcbb, ccaba, ccbaa, ccbcc, aaaaac, aaaaba, aaaabc, aaabac, aabbaa,
- aabbac, aabbbb, aabbbc, aabcac, aabcba, aabccc, aacaab, aacaba, aacbcb,
- aaccab, aaccca, abaabb, abacca, abbcaa, abbcbb, abcaab, abcaac, abcacc,
- abcbba, abcbcb, abcbcc, acaaac, acaacb, acabbb, acacba, acaccb, acbaac,
- acbbcc, acbcab, acbcbb, acbccb, accaab, accbac, accbca, baaabb, baabab,
- baacaa, baacca, bacbbb, bacbcb, baccac, bbaaaa, bbaaca, bbacba, bbaccb,
- bbbaab, bbcbcb, bcabcc, bcbaaa, bcbaab, bcbaca, bcbbca, bcbcca, bccaaa,
- bccacb, bccbab, bccbba, bccccc, caaaca, caaacc, cabaac, cabbbc, cabcca,
- cacabb, cacbac, caccca, cacccc, cbabaa, cbabab, cbabcb, cbacaa, cbacca,
- cbbaca, cbbbaa, cbbbbb, cbbbbc, cbbcaa, cbbccb, cbcaca, cbcacb, cbcacc,
- cbcbab, cbcbca, cbccaa, cbccca, cbcccc, ccabca, ccbbcb, ccbcba, ccbcca,
- cccaca, cccacb, aaaaabb, aaaabba, aaaabbb, aaaaccc, aaabaca, aaabbba,
- aaabbca, aaabbcb, aaabcac, aaabcba, aaacbab, aaaccba, aabaaac, aabaccc,
- aabbaab, aabbaac, aabbaca, aabbbac, aabbbcb, aabcacc, aabcbba, aabccca,
- aacacca, aacbaab, aacbabb, aacbaca, aacbbba, aaccaaa, aaccacb, abababa,
- ababbab, ababbac, ababbbb, ababbcb, ababbcc, ababcba, abacbca, abaccca,
- abbacca, abbbaaa, abbbaba, abbbbcb, abbbcba, abbcbaa, abbcccb, abcabca,
- abcacac, abcacca, abcbaac, abcbaba, abcbacc, abcbcaa, abcbcab, abcbccb,
- abccaba, abccbab, abccbbc, abcccac, acaaaac, acaabab, acaabbc, acabaca,
- acabacc, acabbbc, acabcbc, acacaab, acacbca, acaccaa, acbacba
- Regex: ([cab]|c)(ε&ε)((a&b{2,})&[^a]&b)
- Pos:
- Neg: bb, abc, bac, abaa, abbc, bbab, bbca, bccb, caba, cabc, ccac, ccba,
- aaaba
- Regex: (b|a)([^abc]|c)
- Pos:
- Neg: a, c
- Regex: (((b&a)|[^acb]c)aa[^ca]a{2,5})*
- Pos:
- Neg: ac, bcb, abba, acac, bcac, cabb, aacca, aaccc, abaaa, abaab, abbab,
- abcaa, acbbb, accaa, babaa, babac, babba, babca, bacab, bbbcc, bbcbc,
- bcaac, bcabc, bcbcc, bccaa, bcccc, cabac, cbaab, ccaac, ccabb, ccbcc,
- cccbc, aaaaba, aaaacc, aaabbb
- Regex: [cab]&εc|[^a]a{0}
- Pos:
- Neg: c, abc, baa, bac, aaac, acca, accb, caac, cbab, aabbc, abaac, abbab,
- abbbc, abccb, acaab, acacb, acbaa, acbac, acbcc, accab, baaab, babcc,
- bacaa, bbaba, bbbcb, bbcbc, bcaab, bcbba, bcbbb, bccca, bcccb, caabb,
- cabac, cabbb, cbacc, cbbbb, cbbbc, ccaca, aabaab, aabbba, aacabb, aacacc,
- aacbac, aaccbc, ababba, ababca, abbaab, abbaca, abcbba, abcbbb, abcbbc,
- acacaa, acacba, acbbbc, accaaa, accbcc, acccac
- Regex: (cb|cc{2,5}){1,5}
- Pos: cbcccb, cbcbcccb, cbcccbcb, cccccbcc, cbcbcbcbcc, cbcbcccbcc,
- cbcccccbcc, cccbcbcccb, cccccccccc, cbcccccccccb, cccbcccbcbcc,
- cccccbcbcbcc, cccccccccccc, cbcbcbcbcccbcb, cbcbcbcbcccbcc, cbcbcbcbcccccb,
- cbcbcbcccbcbcc, cbcbcbcccccccb, cbcbcccbcbcbcb, cbcbcccbcbcccb,
- cbcccbcbcbcbcb, cbcccbcbcccccb, cbcccbcccbcccb, cbcccccbcbcbcb,
- cbcccccccccbcc, cccbcbcbcbcbcb, cccbcccbcbcbcb, cccbcccbcbcccc,
- cccbcccccbcbcb, cccbcccccccccb, cccbcccccccccc, cccccbcbcbcccc,
- cccccbcccbcbcb, cccccbcccbcccb, cccccccbcccccb, cbcbcbcbcccbcbcc,
- cbcbcbcccccbcccc, cbcbcbcccccccccb, cbcbcccbcccccccc, cbcbcccccbcbcbcc,
- cbcbcccccbcbcccc, cbcbcccccccccbcb, cbcccbcbcbcbcccc, cbcccbcbcbcccccb,
- cbcccbcbcbcccccc, cbcccbcbcccbcbcc, cbcccbcbcccccccc, cbcccbcccbcccccc,
- cbcccbcccccbcbcb, cbcccbcccccbcccb, cbcccbcccccccbcc, cbcccccbcbcccccc,
- cbcccccbcccccccb, cbcccccccbcccbcb, cbcccccccccbcbcc, cbcccccccccbcccb,
- cccbcbcbcbcccccb, cccbcbcccbcbcccc, cccbcccbcccccbcc, cccbcccccccbcbcb,
- cccccbcbcbcbcbcc, cccccbcccbcbcbcc, cccccbcccbcccbcc, cccccccbcbcbcbcc,
- cccccccbcbcccbcb, cccccccbcccbcccc, cbcbcbcbcbcccccbcb, cbcbcbcbcbcccccccb,
- cbcbcbcbcccbcbcbcb, cbcbcbcbcccbcbcbcc, cbcbcbcbcccbcccccc,
- cbcbcbcccbcbcbcbcb, cbcbcbcccbcbcccccc, cbcbcbcccbcccccccc,
- cbcbcbcccccbcccccb, cbcbcbcccccccbcccc, cbcbcbcccccccccccc,
- cbcbcccbcccbcbcbcb, cbcbcccbcccbcbcbcc, cbcbcccbcccccbcbcc,
- cbcbcccbcccccccccb, cbcbcccccbcbcbcccb, cbcbcccccbcbcccbcb,
- cbcccbcbcbcbcccbcb, cbcccbcccbcccbcccb, cbcccbcccccccbcbcc,
- cbcccccbcbcbcccccb, cbcccccbcbcbcccccc, cbcccccbcbcccbcccb,
- cbcccccbcccbcbcccb, cbcccccccbcbcccbcc, cbcccccccbcbcccccc,
- cbcccccccccbcbcbcc, cbcccccccccbcbcccc, cccbcbcbcbcbcbcbcc
- Neg: bc, aac, abb, aca, acc, caa, cab, aaac, aabb, acac, accc, baab, babb,
- babc, bacb, bbba, bcbb, caac, cbaa, cbba, cbca, ccbc, aabbc, aacaa, aacbc,
- abbcc, abccc, accba, baacb, babbc, bccba, bccbb, bccbc, bccca, cacca,
- caccc, cbbac, ccaba, ccabc, cccca, aaaaac, aaabca, aaabcc, aaacca, aabaac,
- aabacb, aabbca, aabcab, aacbab, aacbac, aacbcc, abaaba, ababbb, abacaa,
- abbcab, abbcba, abbccc, abcabb, abccac, acaaaa, acaabb, acaacc, acabaa,
- acbacc, acbbaa, acbbcc, acbccb, accccc, baaacb, baabba, babcac, babcbb,
- bacaba, bacbac, bacbbc, bacbcb, baccbc, bacccb, bacccc, bbabab, bbacbb,
- bbbbcb, bbbbcc, bbbcba, bcaaab, bcabbb, bcabcb, bcbaaa, bcbcab, caaaab,
- caacba, caacbc, caaccb, cabbca, cabbcc, cabccb, cacacb, cacbcc, cbaaac,
- cbaabb, cbabac, cbbaab, cbbaac, cbbabb, cbcbab, cbccaa, cbccab, cbccac,
- cbccbc, ccaacb, ccabac, ccabca, ccabcc, ccacbb, ccacca, ccbbaa, ccbbbc,
- ccbcbb, cccacc, ccccbb, aaaaabc, aaaabaa, aaabaab, aaabbac, aaabbbc,
- aaabcca, aaacaaa, aaacaac, aaacabc, aaacbba, aaacccc, aabaaca, aababcb,
- aabacaa, aabacbc, aabacca, aabaccc, aabbbca, aabbcbb, aacabac, aacacab,
- aacbacc, aacbbbc, aacbbcc, aacbcbc, aacbccb, aacbccc, abaaaba, abaaacb,
- abaabba, abaabbc, abaabca, abaacca, abababb, ababaca, ababbba, ababcba,
- ababcbc, ababcca, ababccb, abacbbc, abaccab, abbaaca, abbabbb, abbbaab,
- abbbaba, abbbacb, abbbbab, abbbcbb, abbcabb, abbccca, abcaaaa, abcaccc,
- abcbbbc, abcbcba, abccaac, abccaba, abccaca, abccbcb, acaaaac, acaabac,
- acaacaa, acaacbb, acababa, acabacb, acabacc, acabbaa, acabbba, acabbca,
- acacabb, acacbab, acacbac, acacbbb, acacbca, acbaaba, acbabcc, acbacac,
- acbacba, acbacbc, acbaccc, acbbcab, acbbcbc, acbcaaa, acbccaa, acbccab,
- acbccbc, accbbba, accbcbc, accbccc, acccabc, acccaca, acccbab, acccbac,
- accccbb, acccccb, baaaaab, baaabbb, baababa, baababc, baabcac, baabcca,
- baabccc, baacabc, baacacc, baacbbc, baaccaa, baaccbb, bababac, bababca,
- babacac, babacca, babbaaa, babbaca, babbacc, babbbab, babbbac, babbbbb,
- babbbbc, babcbac, babcbbc, babccbb, bacaaba, bacabaa, bacabac, bacacbb,
- bacbaba, bacbcac, baccaac, baccbbc, bbaaaca, bbaabab, bbaabbc, bbaaccc,
- bbababc, bbabbbb, bbabbcc, bbabcba, bbacaab, bbaccba, bbaccca, bbbaaba,
- bbbaacc, bbbabac, bbbabca, bbbabcb, bbbbabb, bbbbaca, bbbbacb, bbbbbab,
- bbbbcba, bbbcbcb, bbbccba, bbbccbc, bbbcccb, bbcaaaa, bbcaaac, bbcaaba,
- bbcaacc, bbcabac, bbcabcb, bbcabcc, bbcacac, bbcbaac, bbccbbc, bbcccaa,
- bbcccbc, bbccccb, bcaaaac, bcaabaa, bcaacbb, bcabaca, bcabbac, bcabcca,
- bcacabc, bcacacb, bcacbba, bcacbca, bcacbcc, bcaccca, bcbaaca, bcbabaa,
- bcbacba, bcbacca, bcbaccb, bcbaccc, bcbbbaa, bcbbcaa, bcbcacb, bcbccbc,
- bccaaca, bccabab, bccacac, bccacca, bccbcbb, bcccbbb, caaaabc, caaabca,
- caaacbb, caabbba, caabcab, caacbaa, cabaaba, cabaabc, cababac, cababba,
- cabacab, cabbaac, cabbbbc, cabbbca, cabcaac, cabcaca, cacaabb, cacabba,
- cacabcb, cacacac, cacbaaa, cacbbaa, cacbcaa, cacbccc, caccacb, caccacc,
- caccbba, caccbca, cbaabcb, cbaacbb, cbabaaa, cbacabb, cbacbcc, cbbaabc,
- cbbabcc, cbbacaa, cbbbaba, cbbbcca, cbbbccb, cbbcabc, cbbccab, cbcaaba,
- cbcaabc, cbcabbc, cbcacab, cbcbbab, cbccacb, cbccbab, cbccbac, cbccbbc,
- cbccccb, ccaacac, ccaacbc, ccaacca, ccababa, ccabaca, ccabbaa, ccabbac,
- ccabbbb, ccabbbc, ccabbca, ccabbcb, ccacabc, ccacbab, ccacbbb, ccbaaab,
- ccbabaa, ccbabbc, ccbbaaa, ccbbaca, ccbbbaa, ccbbbac, ccbbcaa, ccbcaac,
- ccbccaa, ccbccca, cccabaa, cccabba, cccacac, cccbabb, cccbacc, cccbbbb,
- cccbcaa, ccccbac, aaaaaabc, aaaaaacb, aaaaacba, aaaabbaa, aaaabbba,
- aaaabccb, aaaaccba, aaabaaab, aaabaabb, aaabaabc, aaabacaa, aaabbabc,
- aaabbbbb, aaabbbbc, aaabbbcc, aaabbcaa, aaabcaca, aaacabaa, aaacacbc,
- aaacbaac, aaacbacb, aaacbccb, aaaccbac, aaaccbbb, aaacccaa, aaacccbc,
- aabaabcb, aabaacaa, aabaaccb, aababaac, aabababc, aababbab, aababbbb,
- aababbca, aababcaa, aababcab, aababcbc, aababccc, aabacbac, aabaccac,
- aabbaaac, aabbabcc, aabbacca, aabbbcba, aabbcabc, aabbcbab, aabbcbca,
- aabbcbcc, aabcaabb, aabcaacb, aabcabbb, aabcacbc, aabcacca, aabcbaac,
- aabcbaba, aabcbabc, aabcbbab, aabcbbac, aabccbab, aabccbba, aabccbbb,
- aabccbcb, aabcccaa, aacaaaac, aacaaaca, aacaabaa, aacaabbc, aacaacca,
- aacabbbc, aacabbcb, aacacacc, aacbacac, aacbbbab, aacbbcbb, aaccabac,
- aaccabbc, aaccacba, aaccbabb, aaccbacb, aaccbbac, aacccaab, aaccccaa,
- aaccccab, aaccccca, abaaaaba, abaaaabb, abaaaacb, abaaaacc, abaaabaa,
- abaaacab, abaaacbb, abaabaab, abaababb, abaabbab, abaabbcb, abaacaba,
- abaacabb, abaacacc, abaacbbc, ababaacb, abababca, ababacca, ababaccb,
- ababbabc, ababbccc, ababccbc, ababccca
- Regex: ([bac]&a)([^b]&b)
- Pos:
- Neg: c, bc, aaa, aacb, abba, acaa, bacc, bccb, cacb, cbbc, ccac, cccb, aaabc,
- aaaca, aaacc, ababc, abcaa, abcbb, acbbc, accbc, baaac, babac, babcc,
- bcaba, bcbba, bcbbc, caaca, cacaa, cbaaa, cbbbc, cbcab, cbcbb, ccaaa,
- ccbba, cccaa, aaabab, aaabbc, aabbaa, aabbac, aabbca, aacbac, aacbcb,
- aaccab
- Regex: [^cb]ε([^cab]|[^cab]){2,4}
- Pos:
- Neg: bc, abb, abc, baa, bbc, cba, cbb, ccb, abbc, acab, bbbb, bbbc, bcba,
- bcca, caba, ccba, aaaaa, aabac, aacac, aacbb, abaca, abbca, abcab, abcbb,
- acaac, acabb, acbaa, accbc, acccb, baaaa, baacb, bbbba, bbbbc, bbcbb,
- bbccb, bcaaa, bcaab, bcacb, bcacc, bcbac, bcbcb, bccaa, bccca, caabc,
- cacbc, cbabb, cbcaa, cbccc, ccaab, aaabbc, aababb, aabbba, aabbbc, aabbca,
- aacaab, aacbaa, aacbbc, abaaba, abacbc, abbaab, abbacb, abbbaa, abbbba,
- abbbbc, abcaab, abcbac, abccac, acabbb, acacac, acaccc, acbaaa, acbaab,
- acbaac, acbcbc, accaaa, accaab, accaba, accbba, acccbc, acccca, baaaab,
- baaaca, baabcc, babacb, babcab, bacacc, bacbaa, bacbbc, baccac, baccbc,
- bbaaab, bbaaca, bbabab, bbaccb, bbbbca, bbbbcc, bbbccb, bbcaac, bbcbba,
- bbccbb, bbccca, bcaaab, bcaabc, bcabcc, bcbaca, bcbcbc, bccbbb, bccbcc,
- caaaaa, caaacb, caabac, caacaa, caacac, caacbc, cabbaa, cabbac, cabbbb,
- cacabc, caccac, cbaaba, cbabaa, cbacca, cbbaba, cbbbaa, cbbbab, cbbbac,
- cbbbbc, cbcbca, cbcbcb, cbccaa, cbccca, ccaacb, ccacab, ccacbb, ccbbca,
- ccbcab, cccbaa, cccbbc, ccccab, ccccca, cccccb, aaaaaba, aaabaac, aaabbab,
- aaabbbc, aaabcbc, aaacbba, aabaaac, aabaccc, aabbaac, aabbabb, aabbcac,
- aabcaab, aabcbaa, aabcbcc, aabccaa, aacbabb, aacbabc, aacbbca, aacbcbc,
- aaccaca, aaccbaa, aaccbba, aacccab, abaaaab, abaaabb, abaaacb, abaabcb,
- abaacac, ababaab, abacaaa, abacaac, abaccaa, abaccca, abbaaaa, abbbabb,
- abbbbcb, abbbcab, abbcbbc, abbcbca, abbcbcc, abbccac, abbccba, abbccbb,
- abbccca, abbcccc, abcaaba, abcaabb, abcabaa, abcabba, abcabbc, abcacbb,
- abcacbc, abcbccb, abcbccc, abccabb, abccabc, abccbbb, abcccbc, acaaaab,
- acaaaca, acabacb, acabacc, acabcaa, acabcab, acabccc, acaccab
- Regex: cb
- Pos:
- Neg: ac, ba, aac, abb, aca, bbb, aabb, abab, abcc, acac, baba, bbbc, bbcc,
- bcbc, bccc, cbba, cbbc, cbca, ccba, aaacc, aabba, aabbc, aabcc, aacaa,
- abbcb, abcba, abcbb, acbbb, accca, baacb, babcc, bacbb, baccb, bbaba,
- bbabb, bbbab, bbcac, bbcba, bbcca, bcbcc, bccab, caaac, caacc, cabab,
- cabac, cacaa, cacab, cacac, cbacc, cbbbb, cbbbc, cbcbb, ccaac, ccabc,
- ccaca, ccbaa, ccbca, aaaacc, aaabcb, aaacac, aaaccb, aabaaa, aababc,
- aabacc, aabbca, aabcca, aacaaa, aacaba, aacabb, aacbaa, aacbca, abaaab,
- abaaac, ababac, ababbc, abacba, abbaaa, abbaac, abbbac, abbcba, abbcbb,
- abbccb, abccbc, acaacb, acabac, acbaca, acbacc, acbbcb, accaba, baaaaa,
- babbcb, babcbb, babccb, bacaac, bacbbc, bbaaba, bbabaa, bbabba, bbabca,
- bbabcb, bbacaa, bbbbaa, bbbbcb, bbcaaa, bbccab, bbccac, bbcccb, bbcccc,
- bcabbc, bcabca, bcacbb, bcbaaa, bcbabc, bcbccc, caaabb, caabba, caaccb,
- cababc, cabacc, cabbac, cabcaa, cacaac, cacabc, cacbac, cacbbc, cacbcc,
- caccbb, cacccc, cbaaab, cbaccb, cbbcca, cbcaac, cbcaba, cbcbbc, ccabac,
- ccabbc, ccacab
- Regex: (c{2})&bc
- Pos:
- Neg: a, c, ac, ca, cc, aba, acb, bab, bba, cbc, aaba, aabb, abab, abba, acaa,
- acca, bbbc, bcab, bcbb, cacc, cbab, ccaa, ccab, aaaab, aabbb, abaaa, abbaa,
- abbac, abbba, abbbb, abbca, abccb, acaaa, acaba, acbab, acbbc, baaab,
- babaa, babac, bacba, bbaba, bcabc, bcbab, bcbca, cabca, cacac, cacbb,
- cbaaa, cbabb, cbacc, cbbac, cbcaa, ccaaa, ccaba, ccacb, ccacc, ccbbc,
- aaacac, aabacb, aabcbc, aacbab, ababca, abbaba, abbbac, abbbca, abccab,
- abcccc, acaabb, acabba, acacbc, acbbcb, acbbcc, acbcaa, accaba, accabb,
- accacc, accbab, accbba, accbcc, acccac, acccca, baaaab, baaacb, baabab,
- baabbb, baacbc, baaccb, baaccc, bababc, babbab, babcac, bacaba, bacacc,
- bacbba, bacbbb, bacccc, bbaacb, bbabbc, bbabcc, bbbbcb, bbbccb, bbbccc,
- bbcabc, bbcbcc, bcaaac, bcabbb, bcacab, bcacac, bcbbab, bcbbcb, bccaac,
- bccaba, bccbbb, bccbbc, caabaa, caabba, caabbb, caabca, caacac, cababb,
- cabbbc, cabbca, cabcbb, cacbca, caccaa, cbabac, cbbbba, cbbcac, cbbcca,
- cbbccc, cbcaaa, cbcabb, cbcaca, cbcbac, cbcbbb, ccabba, ccacbb, ccacca,
- ccaccb, ccbaba, ccbabc, ccbccb, cccaba, cccacc, cccbac, cccbcc, cccccc,
- aaaaaaa, aaaacac, aaabbaa, aaabbbc, aaabbcc, aaacaca, aaacbbb, aaaccab,
- aabaabb, aababbb, aababcb, aabacba, aabbaaa, aabbabc, aabcabb, aabccab,
- aacaaba, aacacaa, aacaccc, aacbabc, aaccaaa, aaccaab, aaccabb, aaccaca,
- aacccca, abaaaaa, abaaaab, abaabac, abaabca, abaabcc, abaacaa, ababaca,
- ababacc, ababbab, abacbac, abbaaca, abbabac, abbabba, abbacaa, abbacab,
- abbbabb, abbbabc, abbbbbc, abbbcac, abbbcca, abbbccc, abbcaba, abbcacc,
- abbcbbb, abcacbc, abcbaac, abcbabb, abcbacc, abcbbab, abcbbac, abcbbcc,
- abcbcaa, abcbcbb, abcbccb, abccaab, abccaca, abccbca, abcccac, abccccb,
- acaaaca, acaabbb, acaacac, acabaac, acabbac, acabbba, acabbbb, acacbab,
- acacbca, acaccca, acbaaac, acbabac, acbbacc, acbbbaa, acbbbba, acbbcac,
- acbbcba, acbcacb, acbcbaa, acbcbcb, acbccbb, accaaaa, accaacc, accabac,
- accabbb, accacca, accbbcb, accbcaa, acccaab, acccabc, acccbab, acccccc,
- baaaabb, baaaccc, baabbac, baabcbc, baacaba, baacbbb, bababba, babbacb,
- babbbaa, babbbac, babcaac, bacaacb, bacabbc, bacabcb, bacacab, bacaccb,
- bacbbab, bacbcbb, bacbcca, baccbbb, baccbbc, bacccbb, bacccbc, bbaaaaa,
- bbaabba, bbabaaa, bbabbcb, bbbabab, bbbabac, bbbabbc, bbbabcc, bbbacbc,
- bbbaccc, bbbcaba, bbbcbcb, bbbccac, bbcaaba, bbcaacb, bbcaacc, bbcabaa,
- bbcabac, bbcbacc, bbcbbac, bbcbbbb, bbcbcba, bbcbcbc, bbcbccb, bbccbab,
- bcaaaac, bcaacbb, bcabcba, bcabcbc, bcacabc, bcacacb, bcaccbb, bcaccbc,
- bcbabaa, bcbabca, bcbacca, bcbbbbc, bcbbccb, bcbcaac, bcbcacc, bcbcbcb,
- bccaaaa, bccaaab, bccaabc, bccabba, bccbaba, bccbabb, bccbcbb, bccbccc,
- bccccaa, bccccab, caaaabc, caaaaca, caaabcc, caaaccb, caacbbc, caacbcb,
- cabaaaa, cababab, cabacbc, cabbaaa, cabbacb, cabbbaa
- Regex: [^ca]|c
- Pos:
- Neg: bb, caa, ccb, aaab, abaa, abbc, baab, bbbb, bcba, bccb, ccbc, aaabc,
- aaaca, aabaa, aabbb, aabcc, abbac, acaab, acaac, acabb, acacc, babcc,
- bacaa, bacba, bbabc, bbacc, bbbaa, bbbba, bbbbb, bbbca, bbcca, bcabc,
- caaac, caaca, cabab, cabbb, cacbc, cbaac, cbcab, cbcba
- Regex: ([^cab]|b{0,5})((c|a{2,3}){2,})
- Pos: acaaa, accca, acccc, bcaac, caaac, ccacc
- Neg: aa, ba, cc, bcb, aaba, acab, acbc, baba, bacb, cabc, cbba, aabca, ababa,
- abbaa, abbac, abcca, acbbb, accab, bacbc, bbaaa, bbaab, bbbab, caabc,
- cabbc, cacbc, cbbab, cbbac, cbbbc, ccacb, ccbbc, ccbcc, ccccb, aaaabb,
- aaaabc, aaacbb, aaaccb, aabaaa, aabcbb, aabccb, aacacb, aacbcc, abaaac,
- abaacb, abbacb, abbbaa, abbbac, abcaba, abcabc, abcbba, abcccb, acaaba,
- acabba, acacbc, acbaaa, acbbab, acbbba, acbbbc, accbab, accbba, baaabc,
- baacba, babaaa, babacb, babbca, bacbac, baccbb, bbaaab, bbaabb, bbaacb,
- bbabaa, bbabbb, bbbaab, bbbaba, bbbcaa, bbbcbb, bbbcca, bbccba, bcabab,
- bcabca, bcbaab, bcbbab, bcbcaa, bcbccc, bccaba, bcccba, bccccb, caaabb,
- caabab, caabba, caacab, caacba, cabbac, cabbcb, cabccb, cacbbc, cbaaab,
- cbaaac, cbaabc, cbabbb, cbacca, cbbaab, cbbaca, cbbccb, cbcaab, cbcaba,
- cbcacb, cbcbaa, ccabbc, ccbbac, ccbcac, cccbbc, ccccab, aaaabbb, aaabbca,
- aaabccc, aaacbac, aaacbbb, aaacbbc, aaaccbb, aaacccb, aababca, aabcccc,
- aacabac, aacbaaa, aacbaba, aacbabb, aacbacb, aacbacc, aaccaba, aaccbcb,
- abaaacc, abaacca, ababaca, abbaaaa, abbaaac, abbaaba, abbbbcc, abbbcbb,
- abbbcca, abbcabc, abbcccc, abcaaca, abcaacb, abcabbb, abcacca, abcbbbc,
- abcbccb, acabaab, acababa, acabbab, acabbbb, acacaba, acaccab, acaccbb,
- acaccbc, acacccb, acbabab, acbabcc, acbbaac, acbbabc, acbbbbb, acbbbcc,
- acbcaac, acbcbaa, acbcbca, acbcbcb, accabab, accbaba, accbbac, accbbca,
- accbccb, acccbbb, acccbbc, acccccb, baaabaa, baaabab, baaacba, baabbaa,
- baabbab, baabcbb, baabccc, baacbcc, baaccba, bababbb, babacaa, babaccc,
- babbaca, babbbaa, babbbcc, babbcab, babbcba, babccbc, bacbacb, bacbbaa,
- baccbba, baccbbb, baccccb, bbaabaa, bbaabab, bbabaab, bbababb, bbababc,
- bbabacb, bbabcab, bbacbba, bbbaabc, bbbbbba, bbbbbbb, bbbbcaa, bbbbcac,
- bbbcbab, bbcabca, bbcbbaa, bbcbbcc, bbcbcaa, bbcbcbb, bbcbcbc, bbcbccc,
- bbccbab, bbccbbc, bbcccab, bcaaabb, bcaaacb, bcabaab, bcabaca, bcabbba,
- bcabcca, bcacaba, bcacbbb, bcacbbc, bcacbcb, bcbacca, bcbbaac, bcbbbbc,
- bcbcaaa, bcbcabc, bccabbb, bccabcc, bccbcab, bccbcbc, bcccbcb, caabaac,
- caababb, caabbca, caabcac, caacabc, caaccba, cabaaba, cabaacc, cabacca,
- cabbaac, cabbabc, cabbbcc, cabbcbc, cabcabb, cabcabc, cabcbcc, cacbbab,
- cacbbbc, cacbcaa, cacbccb, caccbbb, cacccab, cbaabbc, cbaabcb, cbabcaa,
- cbacaac, cbacaca, cbacacc, cbacbbb, cbacbca, cbaccaa, cbbaaaa, cbbaaca,
- cbbabac, cbbabba, cbbacba, cbbbaaa, cbbbcca, cbbbccc, cbbcabb, cbbcacb,
- cbbcbca, cbcaaaa, cbcaaab, cbcaaca, cbcabab, cbcabbb, cbcacab
- Regex: (a&a&[^b][acb])bε[^ab]b{3,}
- Pos:
- Neg: a, ca, aaa, baa, cbc, aaaa, aaba, babb, baca, bbbb, bcab, bcbc, caab,
- cabb, caca, cccc, aaaac, aacab, aaccb, abbca, abcbc, acaaa, acaab, accbc,
- baabb, babbc, bacab, bacba, bbbbc, bbcaa, bbcbb, caacc, cabac, caccb,
- cbbca, ccaaa, ccacc, ccbbc, cccab, aaaaaa, aaaaac, aaabba, aaabcc, aacabc,
- aacbbc, aaccca, abaaba, abbaac, abbbbc, abbbca, abbcba, abcaca, abcbbb,
- abcbbc, abcbca, abccbb, acaaba, acabba, acbabc, acbbac, acbbbb, acbbbc,
- acbbcc, acbcba, accaba, accbaa, acccab, acccbc, baaaac, baabba, babbcb,
- bacaaa, bacacc, bacbab, baccaa, baccca, bbabac, bbabba, bbbaaa, bbbabb,
- bbbbac, bbbbcb, bbbcba, bbcbac, bbccac, bcaaba, bcabaa, bcabcb, bcbbcb,
- bcbcbb, bcbccb, bccaba, bcccaa, caaaaa, caabca
- Regex: ((cc+)&[abc]|a)(a|[^cab]|(a&[ac]){2,})
- Pos:
- Neg: ab, aba, acb, aacc, abab, abbc, acca, baaa, babb, caaa, caac, caca,
- cacb, cbab, ccca, aaaab, aaaca, aaacc, aabba, aabbc, aaccb, abacb, abcab,
- acaca, acbcb, accaa, accbb, baabc, baacc, babba, baccb, bbaaa, bbbac,
- bcbbb, bccaa, bccbc, cabca, cbbba, cbbca, cbcbc, ccabb, cccbb, ccccb,
- aaaabb, aaaabc, aaabab, aaabba, aaacab, aaacbc, aabaca, aabbcc, aacaab,
- aacaba, aacbbc, aaccac, abaacb, ababba, abacba, abbbbb, abcaaa, abcacb,
- abccaa, abccba, abccbb, acabac, acabba, acaccb, acbbab, acbbbc, acbbcb,
- acbcca, accaba, baaaab, baabbb, bababb, bacaac, bacabb, bacccc, bbaacc,
- bbabcb, bbabcc, bbacab, bbbabb, bbbacb, bbbbaa, bbbccb, bbcaac, bbcbcb,
- bbcccc, bcaaaa, bcacba, bcbabb, bcbabc, bcbaca, bcbbba, bcbbcb, bccaaa,
- bccbba, caaaac, caacbc, cabacc, cabbaa, cabbab, cabcba, cabcca, cabccc,
- cacaba, cacacb, cacbab, cacccb, cbaaaa, cbaaab, cbbaab, cbbaba, cbbcca,
- cbcaaa, cbcbbb, cbccaa, cbccac, ccaacb, ccabbb, ccabcb, ccaccc, ccbabb,
- ccbbac, cccbac, cccbba, cccbbc, aaaabca, aaaabcb, aaabaab, aaabaac,
- aaabbba, aaacbcb, aaacbcc, aaaccac, aabaaaa, aabacac, aabaccb, aabbcab,
- aabcbcc, aacaabc, aacaacc, aacacaa, aacbaca, aacbbac, aacbcbb, aaccaaa,
- aaccabc, aaccbcc, abaaaaa, abaaccb, abaaccc, ababaca, ababacb, ababacc,
- ababbaa, ababcca, ababccb, abacaac, abacbac, abbaaab, abbaaac, abbaaba,
- abbaacb, abbabba, abbacca, abbbaaa, abbbabc, abbbcac, abbbcca, abbcaba,
- abbcacb, abbcbaa, abbcbbc, abbcccb, abbcccc, abcaaac, abcbacc, abcbbaa,
- abcbbba, abcbcaa, abcbcbc, abccbac, abccbbc, acaaaca, acaaacb, acaabab,
- acaabac, acaacac, acabaab, acabacc
- Regex: b|a
- Pos:
- Neg: acb, cca, aacb, abab, abac, accb, babb, bcba, bcbb, caca, cbba, ccaa,
- aabac, aabcc, abbca, abcbc, acaca, accab, baaaa, babbc, babca, babcb,
- bbbac, bbbcc, bccbb, caaab, caaac, cacab, cacca, cbaca, ccaab, aaaacb,
- aaaacc, aaabac, aaabca, aaacab, aaacba
- Regex: (ca{3,4})*
- Pos:
- Neg: b, aac, aba, abb, aabb, aabc, aaca, aacb, abab, abbb, acca, bacb, bbaa,
- caac, cacb, cbaa, cbbc, aaabb, aaacb, aabbc, aabcb, aacaa, aacbc, aacca,
- abbcb, abcac, acbac, acbba, acbcb, accba, acccb, baaac, baaca, babca,
- bbaab, bbaac, bbcac, bbcbc, bbccc, bcacc, bcbaa, bcccb, caacc, cabbb,
- cabcb, cacbb, cacca, cbaaa, cbaba, cbbab, cbbbc, cbcca, ccbab, cccca,
- aaacaa, aaacba
- Regex: bε
- Pos:
- Neg: bc, cb, cbb, cbc, ccb, abac, abcc, baba, bbba, bbcb, bccc, caca, aaabc,
- aabcb, aacca, abacc, abbab, abbbb, abcba, abccc, acaac, acbac, acbcb,
- accab, accbc, baacc, bbbab, bbbcb, bcbcb, caabc, caacc, cabaa, cacbc,
- cbaaa, cbbaa, cbbcc, cbcba, ccaba, ccbaa, ccbbb, cccab, aaaaac, aaaabc,
- aaabaa, aaabab, aaabcc, aababc, aabbac, aacccc, abaaca, abaacb, ababbb,
- abbbcc, abbcab, abcbbc, abcbcb, abccab, abccac, acabcc, accabb, accbba,
- acccac, baaaaa, baaaba, baabab, baacbc, baaccb, babbab, babbba, babbca,
- baccba, bbacaa, bbaccb, bbbaaa, bbbaac, bbbabb, bbbbab, bbbbac, bbbcab,
- bbbccb, bbcaab, bbcacc, bbcbbc, bcaaba, bcabbb, bcabca
-> compiled regenerate.0.2
-> removed regenerate.0.2
-> installed regenerate.0.2
Done.
# To update the current shell environment, run: eval $(opam env)
2026-03-03 04:15.18 ---> saved as "5fb27b20c3aae6c08cca1caed9a5d37bf49319d26f835a70af04ede396dfb48e"
Job succeeded
2026-03-03 04:16.12: Job succeeded