diff --git a/include/mata/cntnfa/TODO b/include/mata/cntnfa/TODO new file mode 100644 index 000000000..9d641f8b2 --- /dev/null +++ b/include/mata/cntnfa/TODO @@ -0,0 +1,13 @@ +2. Register transducer annotation, trida je podtridou (?) + +3. Udelat override pro intersection a union (?) + +6. Predelat na synchronized iterator (?) + +7. Argumentovat ten test prazdnosti protoze je hodne slozity najit clanek a odkaz na clanek (?) + +8. Pouzit regex a benchmark na regexovani a opakovat to 50000 krat nebo velmi velke cislo (?) + +9. Udelat prunik s velkym poctem stavu (?) + +10. Udelat prunik a test nalezitosti jazyka (?) diff --git a/include/mata/cntnfa/algorithms.hh b/include/mata/cntnfa/algorithms.hh new file mode 100644 index 000000000..a1a7bcba7 --- /dev/null +++ b/include/mata/cntnfa/algorithms.hh @@ -0,0 +1,135 @@ +/* algorithms.hh -- Wrapping up algorithms for Cntnfa manipulation which would be otherwise in anonymous namespaces. + */ + +#pragma once + +#include "mata/cntnfa/cntnfa.hh" +#include "mata/simlib/util/binary_relation.hh" + +/** + * Concrete NFA implementations of algorithms, such as complement, inclusion, or universality checking. + * + * This is a separation of the implementation from the interface defined in mata::cntnfa. + * Note, that in mata::cntnfa interface, there are particular dispatch functions calling + * these function according to parameters provided by a user. + * E.g. we can call the following function: `is_universal(aut, alph, {{'algorithm', 'antichains'}})` + * to check for universality based on antichain-based algorithm. + * + * In particular, this includes algorithms for: + * 1. Complementation, + * 2. Inclusion, + * 3. Universality checking, + * 4. Intersection/concatenation with epsilon transitions, or, + * 5. Computing relation. + */ +namespace mata::cntnfa::algorithms { + +/** + * Brzozowski minimization of automata (revert -> determinize -> revert -> determinize). + * @param[in] aut Automaton to be minimized. + * @return Minimized automaton. + */ +Cntnfa minimize_brzozowski(const Cntnfa& aut); + +/** + * Complement implemented by determization, adding sink state and making automaton complete. Then it adds final states + * which were non final in the original automaton. + * @param[in] aut Automaton to be complemented. + * @param[in] symbols Symbols needed to make the automaton complete. + * @param[in] minimize_during_determinization Whether the determinized automaton is computed by (brzozowski) + * minimization. + * @return Complemented automaton. + */ +Cntnfa complement_classical(const Cntnfa& aut, const mata::utils::OrdVector& symbols); + +/** + * Complement implemented by determization using Brzozowski minimization, adding a sink state and making the automaton + * complete. Then it swaps final and non-final states. + * @param[in] aut Automaton to be complemented. + * @param[in] symbols Symbols needed to make the automaton complete. + * @return Complemented automaton. + */ +Cntnfa complement_brzozowski(const Cntnfa& aut, const mata::utils::OrdVector& symbols); + +/** + * Inclusion implemented by complementation of bigger automaton, intersecting it with smaller and then it checks + * emptiness of intersection. + * @param[in] smaller Automaton which language should be included in the bigger one. + * @param[in] bigger Automaton which language should include the smaller one. + * @param[in] alphabet Alphabet of both automata (it is computed automatically, but it is more efficient to set it if + * you have it). + * @param[out] cex A potential counterexample word which breaks inclusion + * @return True if smaller language is included, + * i.e., if the final intersection of smaller complement of bigger is empty. + */ +bool is_included_naive(const Cntnfa& smaller, const Cntnfa& bigger, const Alphabet* alphabet = nullptr, Run* cex = nullptr); + +/** + * Inclusion implemented by antichain algorithms. + * @param[in] smaller Automaton which language should be included in the bigger one + * @param[in] bigger Automaton which language should include the smaller one + * @param[in] alphabet Alphabet of both automata (not needed for antichain algorithm) + * @param[out] cex A potential counterexample word which breaks inclusion + * @return True if smaller language is included, + * i.e., if the final intersection of smaller complement of bigger is empty. + */ +bool is_included_antichains(const Cntnfa& smaller, const Cntnfa& bigger, const Alphabet* alphabet = nullptr, Run* cex = nullptr); + +/** + * Universality check implemented by checking emptiness of complemented automaton + * @param[in] aut Automaton which universality is checked + * @param[in] alphabet Alphabet of the automaton + * @param[out] cex Counterexample word which eventually breaks the universality + * @return True if the complemented automaton has non empty language, i.e., the original one is not universal + */ +bool is_universal_naive(const Cntnfa& aut, const Alphabet& alphabet, Run* cex); + +/** + * Universality checking based on subset construction with antichain. + * @param[in] aut Automaton which universality is checked + * @param[in] alphabet Alphabet of the automaton + * @param[out] cex Counterexample word which eventually breaks the universality + * @return True if the automaton is universal, otherwise false. + */ +bool is_universal_antichains(const Cntnfa& aut, const Alphabet& alphabet, Run* cex); + +Simlib::Util::BinaryRelation compute_relation( + const Cntnfa& aut, + const ParameterMap& params = {{ "relation", "simulation"}, { "direction", "forward"}}); + +/** + * @brief Compute product of two NFAs. + */ +Cntnfa product_counter_nfas(const Cntnfa& lhs, const Cntnfa& rhs); + +/** + * @brief Compute product of two NFAs, final condition is to be specified, with a possibility of using multiple epsilons. + * + * @param[in] lhs First NFA to compute intersection for. + * @param[in] rhs Second NFA to compute intersection for. + * @param[in] first_epsilons The smallest epsilon. + * @param[in] final_condition The predicate that tells whether a pair of states is final (conjunction for intersection). + * @param[out] prod_map Can be used to get the mapping of the pairs of the original states to product states. + * Mostly useless, it is only filled in and returned if !=nullptr, but the algorithm internally uses another data structures, + * because this one is too slow. + * @return NFA as a product of NFAs @p lhs and @p rhs with ε-transitions preserved. + */ +Cntnfa product(const Cntnfa& lhs, const Cntnfa& rhs, const std::function && final_condition, + const Symbol first_epsilon = EPSILON, std::unordered_map, State> *prod_map = nullptr); + +/** + * @brief Concatenate two NFAs. + * + * Supports epsilon symbols when @p use_epsilon is set to true. + * @param[in] lhs First automaton to concatenate. + * @param[in] rhs Second automaton to concatenate. + * @param[in] epsilon Epsilon to be used co concatenation (provided @p use_epsilon is true) + * @param[in] use_epsilon Whether to concatenate over epsilon symbol. + * @param[out] lhs_state_renaming Map mapping lhs states to result states. + * @param[out] rhs_state_renaming Map mapping rhs states to result states. + * @return Concatenated automaton. + */ +Cntnfa concatenate_eps(const Cntnfa& lhs, const Cntnfa& rhs, const Symbol& epsilon, bool use_epsilon = false, + StateRenaming* lhs_state_renaming = nullptr, StateRenaming* rhs_state_renaming = nullptr); + +} // namespace mata::cntnfa::algorithms. diff --git a/include/mata/cntnfa/annotations.hh b/include/mata/cntnfa/annotations.hh new file mode 100644 index 000000000..e9ef67fef --- /dev/null +++ b/include/mata/cntnfa/annotations.hh @@ -0,0 +1,374 @@ +// TODO: Insert file header. + +#pragma once + +#include + +#include "mata/utils/ord-vector.hh" +#include "mata/cntnfa/types.hh" + +using namespace mata::utils; + +namespace mata::cntnfa { + +/// All existing annotation types. +enum class AnnotationType { + CounterAssign, + CounterIncrement, + CounterEqual, + CounterNotEqual, + CounterGreater, + CounterLess, + CounterGreaterEqual, + CounterLessEqual, + Unknown +}; + +/// State with an annotation (@c State @c state and @c size_t @c annotation_id). +struct AnnotationState { + State state; ///< Automaton state. + size_t annotations_id; ///< Unique ID for the position in the vector of transition annotations collection. + + AnnotationState() : state(), annotations_id(UNDEFINED_ANNOTATIONS) {} + AnnotationState(const State state, size_t annotations_id) : state(state), annotations_id(annotations_id) {} // NOLINT(*-explicit-constructor) + + AnnotationState(const AnnotationState&) = default; + AnnotationState(AnnotationState&&) = default; + AnnotationState& operator=(const AnnotationState&) = default; + AnnotationState& operator=(AnnotationState&&) = default; + + AnnotationState& operator++() { ++state; return *this; } + + AnnotationState(const State& state): state{ state }, annotations_id(UNDEFINED_ANNOTATIONS) {} // NOLINT(*-explicit-constructor) + AnnotationState(State&& state): state{ state }, annotations_id(UNDEFINED_ANNOTATIONS) {} // NOLINT(*-explicit-constructor) + + auto operator<=>(const State& other) const { return state <=> other; } + bool operator==(const State other) const { return state == other; } + auto operator<=>(const AnnotationState&) const = default; + bool operator==(const AnnotationState& other) const { return state == other; } + + operator State() const { return state; } // NOLINT(*-explicit-constructor) +}; + +/// TODO: Write a comment for doxygen. +class AnnotationStateSet : public mata::utils::OrdVector { +public: + AnnotationStateSet() = default; + + AnnotationStateSet(State state) { // NOLINT(*-explicit-constructor) + this->push_back(AnnotationState(state)); + } + AnnotationStateSet(StateSet& state_set) { // NOLINT(*-explicit-constructor) + for (const State& state: state_set) { + this->push_back(state); + } + } + AnnotationStateSet(const StateSet& state_set) { + for (const State& state : state_set) { + this->push_back(AnnotationState(state)); + } + } + AnnotationStateSet(StateSet&& state_set) { // NOLINT(*-explicit-constructor) + for (const State& state: state_set) { + this->push_back(state); + } + } + AnnotationStateSet& operator=(const StateSet& state_set) { + for (const State& state: state_set) { + this->push_back(state); + } + return *this; + } + AnnotationStateSet& operator=(StateSet&& state_set) { + for (const State& state: state_set) { + this->push_back(state); + } + return *this; + } + + AnnotationStateSet(const AnnotationStateSet& counter_state_set) = default; + AnnotationStateSet(AnnotationStateSet&& counter_state_set) noexcept = default; + AnnotationStateSet& operator=(const AnnotationStateSet& counter_state_set) = default; + AnnotationStateSet& operator=(AnnotationStateSet&& counter_state_set) noexcept = default; + + // FIXME: This is severely limiting. Basically, this cannot ever be used in production unless explicitly requested. + // Should this be explicit? Probably no, but some iteration over CounterStateSet which would behave as a StateSet would be good. + // But that is already happening, no? + operator StateSet() const { // NOLINT(*-explicit-constructor) + StateSet state_set; + for (const auto& target : *this) { + state_set.push_back(target.state); + } + return state_set; + } +}; + +// Added for better readability. +using Target = AnnotationState; +using TargetSet = AnnotationStateSet; + +/// Class with a virtual interface for different types of annotations. +// Note: This is convenient to implement various operations during transitions. +class TransitionAnnotation { +protected: + size_t register_id = UNDEFINED_REGISTER; ///< The ID of the register to be used in the annotation. + RegisterValue value = 0; ///< The value to be used in the annotation. + +public: + TransitionAnnotation() = default; + TransitionAnnotation(size_t register_id, RegisterValue value) + : register_id(register_id), value(value) {} + virtual ~TransitionAnnotation() = default; + + size_t get_register_id() const { return register_id; } + RegisterValue get_value() const { return value; } + + virtual void update(CounterSet& counters) const = 0; + virtual bool guard(const CounterSet& counters) const = 0; + virtual bool apply(CounterSet&) const = 0; + virtual AnnotationType get_type() const = 0; +}; + +/// Class for assigning a value to a counter by its ID. +// Note: (:= c0 0) is a counter assignment in Mata format. +class CounterAssign : public TransitionAnnotation { +public: + CounterAssign() = default; + CounterAssign(size_t counter_id, CounterValue value) + : TransitionAnnotation(counter_id, value) {} + + bool operator==(const CounterAssign& other) const { + return register_id == other.register_id && value == other.value; + } + auto operator<=>(const CounterAssign& other) const { + if (auto cmp = register_id <=> other.register_id; cmp != 0) { + return cmp; + } + return value <=> other.value; + } + + void update(CounterSet& counters) const override; + bool guard(const CounterSet& counters) const override; + bool apply(CounterSet& counters) const override; + AnnotationType get_type() const override; +}; + +/// Class for incrementing and decrementing a counter by its ID. +// Note: (+ c0 1) or (+ c0 -1) is a counter increment in Mata format. +class CounterIncrement : public TransitionAnnotation { +public: + CounterIncrement() = default; + CounterIncrement(size_t counter_id, CounterValue value) + : TransitionAnnotation(counter_id, value) {} + + bool operator==(const CounterIncrement& other) const { + return register_id == other.register_id && value == other.value; + } + auto operator<=>(const CounterIncrement& other) const { + if (auto cmp = register_id <=> other.register_id; cmp != 0) { + return cmp; + } + return value <=> other.value; + } + + void update(CounterSet& counters) const override; + bool guard(const CounterSet& counters) const override; + bool apply(CounterSet& counters) const override; + AnnotationType get_type() const override; +}; + +/// Class for checking if a counter's value is equal to the value. +// Note: (= c0 0) is a counter equal check in Mata format. +class CounterEqual : public TransitionAnnotation { +public: + CounterEqual() = default; + CounterEqual(size_t counter_id, CounterValue value) + : TransitionAnnotation(counter_id, value) {} + + bool operator==(const CounterEqual& other) const { + return register_id == other.register_id && value == other.value; + } + auto operator<=>(const CounterEqual& other) const { + if (auto cmp = register_id <=> other.register_id; cmp != 0) { + return cmp; + } + return value <=> other.value; + } + + void update(CounterSet& counters) const override; + bool guard(const CounterSet& counters) const override; + bool apply(CounterSet& counters) const override; + AnnotationType get_type() const override; +}; + +/// Class for checking if a counter's value is NOT equal to the value. +// Note: (!= c0 0) is a counter NOT equal check in Mata format. +class CounterNotEqual : public TransitionAnnotation { +public: + CounterNotEqual() = default; + CounterNotEqual(size_t counter_id, CounterValue value) + : TransitionAnnotation(counter_id, value) {} + + bool operator==(const CounterNotEqual& other) const { + return register_id == other.register_id && value == other.value; + } + auto operator<=>(const CounterNotEqual& other) const { + if (auto cmp = register_id <=> other.register_id; cmp != 0) { + return cmp; + } + return value <=> other.value; + } + + void update(CounterSet& counters) const override; + bool guard(const CounterSet& counters) const override; + bool apply(CounterSet& counters) const override; + AnnotationType get_type() const override; +}; + +/// Class for checking if a counter's value is greater than a threshold. +// Note: (> c0 0) is a counter greater than check in Mata format. +class CounterGreater : public TransitionAnnotation { +public: + CounterGreater() = default; + CounterGreater(size_t counter_id, CounterValue value) + : TransitionAnnotation(counter_id, value) {} + + bool operator==(const CounterGreater& other) const { + return register_id == other.register_id && value == other.value; + } + auto operator<=>(const CounterGreater& other) const { + if (auto cmp = register_id <=> other.register_id; cmp != 0) return cmp; + return value <=> other.value; + } + + void update(CounterSet& counters) const override; + bool guard(const CounterSet& counters) const override; + bool apply(CounterSet& counters) const override; + AnnotationType get_type() const override; +}; + +/// Class for checking if a counter's value is less than a threshold. +// Note: (< c0 0) is a counter less than check in Mata format. +class CounterLess : public TransitionAnnotation { +public: + CounterLess() = default; + CounterLess(size_t counter_id, CounterValue value) + : TransitionAnnotation(counter_id, value) {} + + bool operator==(const CounterLess& other) const { + return register_id == other.register_id && value == other.value; + } + auto operator<=>(const CounterLess& other) const { + if (auto cmp = register_id <=> other.register_id; cmp != 0) return cmp; + return value <=> other.value; + } + + void update(CounterSet& counters) const override; + bool guard(const CounterSet& counters) const override; + bool apply(CounterSet& counters) const override; + AnnotationType get_type() const override; +}; + +/// Class for checking if a counter's value is greater than a threshold or equal to it. +// Note: (>= c0 0) is a counter greater or equal check in Mata format. +class CounterGreaterEqual : public TransitionAnnotation { +public: +CounterGreaterEqual() = default; + CounterGreaterEqual(size_t counter_id, CounterValue value) + : TransitionAnnotation(counter_id, value) {} + + bool operator==(const CounterGreaterEqual& other) const { + return register_id == other.register_id && value == other.value; + } + auto operator<=>(const CounterGreaterEqual& other) const { + if (auto cmp = register_id <=> other.register_id; cmp != 0) return cmp; + return value <=> other.value; + } + + void update(CounterSet& counters) const override; + bool guard(const CounterSet& counters) const override; + bool apply(CounterSet& counters) const override; + AnnotationType get_type() const override; +}; + +/// Class for checking if a counter's value is less than a threshold or equal to it. +// Note: (<= c0 0) is a counter less or equal check in Mata format. +class CounterLessEqual : public TransitionAnnotation { +public: + CounterLessEqual() = default; + CounterLessEqual(size_t counter_id, CounterValue value) + : TransitionAnnotation(counter_id, value) {} + + bool operator==(const CounterLessEqual& other) const { + return register_id == other.register_id && value == other.value; + } + auto operator<=>(const CounterLessEqual& other) const { + if (auto cmp = register_id <=> other.register_id; cmp != 0) return cmp; + return value <=> other.value; + } + + void update(CounterSet& counters) const override; + bool guard(const CounterSet& counters) const override; + bool apply(CounterSet& counters) const override; + AnnotationType get_type() const override; +}; + +class AnnotationCollection { +private: + std::vector>> annotations; + +public: + AnnotationCollection() : annotations{} {} + + OrdVector>& operator[](size_t annotations_id) { + if (annotations_id >= annotations.size()) { + throw std::out_of_range("Annotation ID is out of range."); + } + return annotations[annotations_id]; + } + const OrdVector>& operator[](size_t annotations_id) const { + if (annotations_id >= annotations.size()) { + throw std::out_of_range("Annotation ID is out of range."); + } + return annotations[annotations_id]; + } + + /** + * Allocate annotation sets up to "size" sets, creating an empty set for yet unallocated set. + * "size" has to be at least size() + 1. + */ + void allocate(const size_t size); + + /** + * Get the total number of annotation sets. + */ + size_t size() const; + + /** + * Clear all annotations. + */ + void clear(); + + /** + * Insert an annotation into annotations vector using index. + */ + void insert(std::shared_ptr annotation, size_t index); + + /** + * Create a new annotation set at the end of the vector, inserting the annotation into it and returning its index. + */ + size_t insert(std::shared_ptr annotation); +}; + +} // namespace mata::cntnfa. + +// Hash specialization for CounterState. +namespace std { + template<> + struct hash { + size_t operator()(const mata::cntnfa::AnnotationState& as) const noexcept { + // Note: Hash the State (unsigned long). + return std::hash{}(as.state); + } + }; +} // namespace std. diff --git a/include/mata/cntnfa/builder.hh b/include/mata/cntnfa/builder.hh new file mode 100644 index 000000000..8644833d0 --- /dev/null +++ b/include/mata/cntnfa/builder.hh @@ -0,0 +1,96 @@ +// TODO: Insert file header. + +#pragma once + +#include + +#include "mata/cntnfa/cntnfa.hh" +#include "mata/parser/inter-aut.hh" + +/** + * Namespace providing options to build NFAs. + */ +namespace mata::cntnfa::builder { + +using namespace mata::cntnfa; + +using NameStateMap = std::unordered_map; + +/** + * Create an automaton accepting only a single @p word. + */ +Cntnfa create_single_word_nfa(const std::vector& word); + +/** + * Create an automaton accepting only a single @p word. + * + * @param word Word to accept. + * @param alphabet Alphabet to use in NFA for translating word into symbols. If specified, the alphabet has to contain + * translations for all of the word symbols. If left empty, a new alphabet with only the symbols of the word will be + * created. + */ +Cntnfa create_single_word_nfa(const std::vector& word, Alphabet* alphabet = nullptr); + +/** + * Create automaton accepting only epsilon string. + */ +Cntnfa create_empty_string_nfa(); + +/** + * Create automaton accepting sigma star over the passed alphabet. + * + * @param[in] alphabet Alphabet to construct sigma star automaton with. When alphabet is left empty, the default empty + * alphabet is used, creating an automaton accepting only the empty string. + */ +Cntnfa create_sigma_star_nfa(Alphabet* alphabet = new OnTheFlyAlphabet{}); + +/** Construct an automaton with counters using ParsedSection */ +Cntnfa construct_counter_nfa(const mata::parser::ParsedSection& parsec, Alphabet* alphabet, NameStateMap* state_map = nullptr); + +/** Loads an automaton from Parsed object */ +// TODO this function should the same thing as the one taking IntermediateAut or be deleted +Cntnfa construct(const mata::parser::ParsedSection& parsec, Alphabet* alphabet, NameStateMap* state_map = nullptr); + +/** Loads an automaton from Parsed object */ +Cntnfa construct(const mata::IntermediateAut& inter_aut, Alphabet* alphabet, NameStateMap* state_map = nullptr); +/** Loads an automaton from Parsed object; version for python binding */ +void construct( + Cntnfa* result, const mata::IntermediateAut& inter_aut, Alphabet* alphabet, NameStateMap* state_map = nullptr +); + +template +Cntnfa construct(const ParsedObject& parsed, Alphabet* alphabet = nullptr, + NameStateMap* state_map = nullptr) { + OnTheFlyAlphabet tmp_alphabet{}; + if (!alphabet) { + alphabet = &tmp_alphabet; + } + return construct(parsed, alphabet, state_map); +} // construct(). + +/** + * Parse NFA from the mata format in an input stream. + * + * @param nfa_stream Input stream containing NFA in mata format. + * @throws std::runtime_error Parsing of NFA fails. + */ +Cntnfa parse_from_mata(std::istream& nfa_stream); + +/** + * Parse NFA from the mata format in a string. + * + * @param nfa_stream String containing NFA in mata format. + * @throws std::runtime_error Parsing of NFA fails. + */ +Cntnfa parse_from_mata(const std::string& nfa_in_mata); + +/** + * Parse NFA from the mata format in a file. + * + * @param nfa_stream Path to the file containing NFA in mata format. + * @throws std::runtime_error @p nfa_file does not exist. + * @throws std::runtime_error Parsing of NFA fails. + */ +Cntnfa parse_from_mata(const std::filesystem::path& nfa_file); + +} // namespace mata::cntnfa::builder. diff --git a/include/mata/cntnfa/cntnfa.hh b/include/mata/cntnfa/cntnfa.hh new file mode 100644 index 000000000..51d7a68c1 --- /dev/null +++ b/include/mata/cntnfa/cntnfa.hh @@ -0,0 +1,867 @@ +/* cntnfa.hh -- Nondeterministic finite automaton (over finite words) with annotations. + */ + +#pragma once + +// Static data structures, such as search stack, in algorithms. Might have some effect on some algorithms (like +// fragile_revert). +//#define _STATIC_STRUCTURES_ + +#include +#include +#include +#include +#include +#include + +#include "mata/alphabet.hh" +#include "mata/utils/utils.hh" +#include "mata/utils/ord-vector.hh" +#include "mata/utils/sparse-set.hh" +#include "mata/cntnfa/annotations.hh" +#include "mata/cntnfa/types.hh" +#include "mata/cntnfa/delta.hh" + +/** + * @brief Nondeterministic Finite Automata including structures, transitions and algorithms. + * + * In particular, this includes: + * 1. Structures (Automaton, Transitions, Results, Delta), + * 2. Algorithms (operations, checks, tests), + * 3. Constructions. + * + * Other algorithms are included in mata::cntnfa::Plumbing (simplified API for, e.g., binding) + * and mata::cntnfa::algorithms (concrete implementations of algorithms, such as for complement). + */ +namespace mata::cntnfa { + +/** + * A struct representing an NFA. + */ +struct Cntnfa { +public: + /** + * @brief For state q, delta[q] keeps the list of transitions ordered by symbols. + * + * The set of states of this automaton are the numbers from 0 to the number of states minus one. + */ + Delta delta; + utils::SparseSet initial{}; + utils::SparseSet final{}; + + AnnotationCollection annotation_collection; ///< Annotation collection for storing annotations. + CounterSet counter_set; ///< Counter register set for storing counters. + + Alphabet* alphabet = nullptr; ///< The alphabet which can be shared between multiple automata. + /// Key value store for additional attributes for the NFA. Keys are attribute names as strings and the value types + /// are up to the user. + /// For example, we can set up attributes such as "state_dict" for state dictionary attribute mapping states to their + /// respective names, or "transition_dict" for transition dictionary adding a human-readable meaning to each + /// transition. + // TODO: When there is a need for state dictionary, consider creating default library implementation of state + // dictionary in the attributes. + std::unordered_map attributes{}; + +public: + explicit Cntnfa(Delta delta = {}, utils::SparseSet initial_states = {}, utils::SparseSet final_states = {}, + AnnotationCollection annotation_collection = {}, CounterSet counter_set = {}, + Alphabet* alphabet = nullptr) + : delta(std::move(delta)), initial(std::move(initial_states)), final(std::move(final_states)), + annotation_collection(std::move(annotation_collection)), counter_set(std::move(counter_set)), + alphabet(alphabet) {} + + /** + * @brief Construct a new explicit NFA with num_of_states states and optionally set initial and final states. + * + * @param[in] num_of_states Number of states for which to preallocate Delta. + */ + explicit Cntnfa(const unsigned long num_of_states, StateSet initial_states = {}, StateSet final_states = {}, + AnnotationCollection annotation_collection = {}, CounterSet counter_set = {}, + Alphabet* alphabet = nullptr) + : delta(num_of_states), initial(initial_states), final(final_states), + annotation_collection(annotation_collection), counter_set(counter_set), + alphabet(alphabet) {} + + /** + * @brief Construct a new explicit NFA from other NFA. + */ + Cntnfa(const Cntnfa& other) = default; + + Cntnfa(Cntnfa&& other) noexcept + : delta{ std::move(other.delta) }, + initial{ std::move(other.initial) }, final{ std::move(other.final) }, + annotation_collection{ std::move(other.annotation_collection) }, + counter_set{ std::move(other.counter_set) }, + alphabet{ other.alphabet }, attributes{ std::move(other.attributes) } { other.alphabet = nullptr; } + + Cntnfa& operator=(const Cntnfa& other) = default; + Cntnfa& operator=(Cntnfa&& other) noexcept; + + /** + * Add a new (fresh) state to the automaton. + * @return The newly created state. + */ + State add_state(); + + /** + * Add state @p state to @c delta if @p state is not in @c delta yet. + * @return The requested @p state. + */ + State add_state(State state); + + /** + * @brief Get the current number of states in the whole automaton. + * + * This includes the initial and final states as well as states in the transition relation. + * @return The number of states. + */ + size_t num_of_states() const; + + /** + * @brief Create an annotation set in the collection of annotations. + * + * @return The index of annotation set. + */ + size_t create_annotation_set(); + + /** + * @brief Add the @p annotation to the annotation set with @p annotations_id index. + * + * @param[in] annotations_id The index of annotation set to insert. + * @param[in] annotation The transition annotation to insert. + * @return The index of annotation set for this annotation. + */ + size_t add_annotation(size_t annotations_id, std::shared_ptr annotation); + + /** + * @brief Get the total number of annotation sets in annotation collection. + * + * @return The number of annotation sets. + */ + size_t num_of_annotation_sets() const; + + /** + * @brief Get the number of counters in the automaton. + * + * @return The number of counters. + */ + size_t num_of_counters() const; + + /** + * @brief Get the annotation from @p annotations_id index. + * + * @param[in] annotations_id The index of annotation set in annotation collection. + * @return The annotation set with @p annotations_id index. + */ + const OrdVector>& get_annotation_set(size_t annotations_id) const; + + /** + * Unify initial states into a single new initial state. + */ + void unify_initial(); + + /** + * Unify final states into a single new final state. + */ + void unify_final(); + + /** + * Swap final and non-final states in-place. + */ + Cntnfa& swap_final_nonfinal() { final.complement(num_of_states()); return *this; } + + bool is_state(const State& state_to_check) const { return state_to_check < num_of_states(); } + + /** + * @brief Clear the underlying NFA to a blank NFA. + * + * The whole NFA is cleared, each member is set to its zero value. + */ + void clear(); + + /** + * @brief Check if @c this is exactly identical to @p aut. + * + * This is exact equality of automata, including state numbering (so even stronger than isomorphism), + * essentially only useful for testing purposes. + * @return True if automata are exactly identical, false otherwise. + */ + bool is_identical(const Cntnfa& aut) const; + + /** + * @brief Get set of reachable states. + * + * Reachable states are states accessible from any initial state. + * @return Set of reachable states. + * TODO: with the new get_useful_states, it might be useless now. + */ + StateSet get_reachable_states() const; + + /** + * @brief Get set of terminating states. + * + * Terminating states are states leading to any final state. + * @return Set of terminating states. + * TODO: with the new get_useful_states, it might be useless now. + */ + StateSet get_terminating_states() const; + + /** + * @brief Get the useful states using a modified Tarjan's algorithm. A state + * is useful if it is reachable from an initial state and can reach a final state. + * + * @return BoolVector Bool vector whose ith value is true iff the state i is useful. + */ + BoolVector get_useful_states() const; + + /** + * @brief Structure for storing callback functions (event handlers) utilizing + * Tarjan's SCC discover algorithm. + */ + struct TarjanDiscoverCallback { + // event handler for the first-time state discovery + std::function state_discover; + // event handler for SCC discovery (together with the whole Tarjan stack) + std::function&, const std::vector&)> scc_discover; + // event handler for state in SCC discovery + std::function scc_state_discover; + // event handler for visiting of the state successors + std::function succ_state_discover; + }; + + /** + * @brief Tarjan's SCC discover algorihm. + * + * @param callback Callbacks class to instantiate callbacks for the Tarjan's algorithm. + */ + void tarjan_scc_discover(const TarjanDiscoverCallback& callback) const; + + /** + * @brief Remove inaccessible (unreachable) and not co-accessible (non-terminating) states in-place. + * + * Remove states which are not accessible (unreachable; state is accessible when the state is the endpoint of a path + * starting from an initial state) or not co-accessible (non-terminating; state is co-accessible when the state is + * the starting point of a path ending in a final state). + * + * @param[out] state_renaming Mapping of trimmed states to new states. + * @return @c this after trimming. + */ + Cntnfa& trim(StateRenaming* state_renaming = nullptr); + + /** + * @brief Returns vector ret where ret[q] is the length of the shortest path from any initial state to q + */ + std::vector distances_from_initial() const; + + /** + * @brief Returns vector ret where ret[q] is the length of the shortest path from q to any final state + */ + std::vector distances_to_final() const; + + /** + * @brief Get some shortest accepting run from state @p q + * + * Assumes that @p q is a state of this automaton and that there is some accepting run from @p q + * + * @param distances_to_final Vector of the lengths of the shortest runs from states (can be computed using distances_to_final()) + */ + Run get_shortest_accepting_run_from_state(State q, const std::vector& distances_to_final) const; + + /** + * Remove epsilon transitions from the automaton. + */ + void remove_epsilon(Symbol epsilon = EPSILON); + + /** + * @brief In-place concatenation. + */ + Cntnfa& concatenate(const Cntnfa& aut); + + /** + * @brief In-place nondeterministic union of counter NFA with @p aut. + * Counter with the same name are shared between the two automata. + */ + Cntnfa& unite_nondet_counter_nfa_with(const Cntnfa &aut); + + /** + * @brief In-place nondeterministic union with @p aut. + * + * Does not add epsilon transitions, just unites initial and final states. + */ + Cntnfa& unite_nondet_with(const Cntnfa &aut); + + /** + * Unify transitions to create a directed graph with at most a single transition between two states. + * @param[in] abstract_symbol Abstract symbol to use for transitions in digraph. + * @return An automaton representing a directed graph. + */ + Cntnfa get_one_letter_aut(Symbol abstract_symbol = 'x') const; + + /** + * Check whether @p symbol is epsilon symbol or not. + * @param symbol Symbol to check. + * @return True if the passed @p symbol is epsilon, false otherwise. + */ + bool is_epsilon(Symbol symbol) const { + // TODO: When multiple epsilon symbols specification inside the alphabets is implemented, update this check to + // reflect the new changes: + // Check for alphabet in the NFA, check for specified epsilon symbol and compare. Otherwise, compare with the + // default epsilon symbol EPSILON. + return symbol == EPSILON; + } + + /** + * Unify transitions to create a directed graph with at most a single transition between two states. + * + * @param[out] result An automaton representing a directed graph. + */ + void get_one_letter_aut(Cntnfa& result) const; + + /** + * @brief Prints the automaton in DOT format + * + * @return automaton in DOT format + */ + std::string print_to_dot() const; + + /** + * @brief Prints the automaton to the output stream in DOT format + */ + void print_to_dot(std::ostream &output) const; + + /** + * @brief Prints the automaton in mata format + * + * If you need to parse the automaton again, use IntAlphabet in construct() + * + * @return automaton in mata format + * TODO handle alphabet of the automaton, currently we print the exact value of the symbols + */ + std::string print_to_mata() const; + + /** + * @brief Prints the automaton to the output stream in mata format + * + * If you need to parse the automaton again, use IntAlphabet in construct() + * + * TODO handle alphabet of the automaton, currently we print the exact value of the symbols + */ + void print_to_mata(std::ostream &output) const; + + // TODO: Relict from VATA. What to do with inclusion/ universality/ this post function? Revise all of them. + StateSet post(const StateSet& states, const Symbol& symbol) const; + + /** + * @brief Check whether the language of counter NFA is empty. + */ + bool is_counter_nfa_lang_empty(Run* cex = nullptr) const; + + /** + * Check whether the language of NFA is empty. + * Currently calls is_lang_empty_scc if cex is null + * @param[out] cex Counter-example path for a case the language is not empty. + * @return True if the language is empty, false otherwise. + */ + bool is_lang_empty(Run* cex = nullptr) const; + + /** + * @brief Check if the language is empty using Tarjan's SCC discover algorithm. + * + * @return Language empty <-> True + */ + bool is_lang_empty_scc() const; + + /** + * @brief Test whether an automaton is deterministic. + * + * I.e., whether it has exactly one initial state and every state has at most one outgoing transition over every + * symbol. + * Checks the whole automaton, not only the reachable part + */ + bool is_deterministic() const; + + /** + * @brief Test for automaton completeness with regard to an alphabet. + * + * An automaton is complete if every reachable state has at least one outgoing transition over every symbol. + */ + bool is_complete(Alphabet const* alphabet = nullptr) const; + + /** + * @brief Is the automaton graph acyclic? Used for checking language finiteness. + * + * @return true <-> Automaton graph is acyclic. + */ + bool is_acyclic() const; + + /** + * @brief Is the automaton flat? + * + * Flat automaton is an NFA whose every SCC is a simple loop. Basically each state in an + * SCC has at most one successor within this SCC. + * + * @return true <-> Automaton graph is flat. + */ + bool is_flat() const; + + /** + * Fill @p alphabet_to_fill with symbols from @p nfa. + * @param[in] nfa NFA with symbols to fill @p alphabet_to_fill with. + * @param[out] alphabet_to_fill Alphabet to be filled with symbols from @p nfa. + */ + void fill_alphabet(mata::OnTheFlyAlphabet& alphabet_to_fill) const; + + /// Is the language of the automaton universal? + bool is_universal(const Alphabet& alphabet, Run* cex = nullptr, + const ParameterMap& params = {{ "algorithm", "antichains" }}) const; + /// Is the language of the automaton universal? + bool is_universal(const Alphabet& alphabet, const ParameterMap& params) const; + + /// This method checks whether a given run (input word) is accepted by a counter NFA. + bool is_in_lang_of_counter_nfa(const Run& run) const; + /// Checks whether a word is in the language of the counter NFA. + bool is_in_lang_of_counter_nfa(const Word& word) { + return is_in_lang_of_counter_nfa(Run{ word, {} }); + } + + /// Checks whether a word is in the language of an automaton. + bool is_in_lang(const Run& word) const; + /// Checks whether a word is in the language of an automaton. + bool is_in_lang(const Word& word) { + return is_in_lang(Run{ word, {} }); + } + + /// Checks whether the prefix of a string is in the language of an automaton + bool is_prfx_in_lang(const Run& word) const; + + std::pair get_word_for_path(const Run& run) const; + + /** + * @brief Get the set of all words in the language of the automaton whose length is <= @p max_length + * + * If you have an automaton with finite language (can be checked using @ref is_acyclic), + * you can get all words by calling + * get_words(aut.num_of_states()) + */ + std::set get_words(unsigned max_length) const; + + /** + * @brief Get any arbitrary accepted word in the language of the automaton. + * + * The automaton is searched using DFS, returning a word for the first reached final state. + */ + std::optional get_word(Symbol first_epsilon = EPSILON) const; + + /** + * @brief Get any arbitrary accepted word in the language of the complement of the automaton. + * + * The automaton is lazily determinized and made complete. The algorithm returns an arbitrary word from the + * complemented NFA constructed until the first macrostate without any final states in the original automaton is + * encountered. + * + * @param[in] alphabet Alphabet to use for computing the complement. If @c nullptr, uses @c this->alphabet when + * defined, otherwise uses @c this->delta.get_used_symbols(). + * + * @pre The automaton does not contain any epsilon transitions. + * TODO: Support lazy epsilon closure? + * @return An arbitrary word from the complemented automaton, or @c std::nullopt if the automaton is universal on + * the chosen set of symbols for the complement. + */ + std::optional get_word_from_complement(const Alphabet* alphabet = nullptr) const; + + /** + * @brief Make NFA complete in place. + * + * For each state 0,...,this->num_of_states()-1, add transitions with "missing" symbols from @p alphabet + * (symbols that do not occur on transitions from given state) to @p sink_state. If @p sink_state does not belong + * to the NFA, it is added to it, but only in the case that some transition to @p sink_state was added. + * In the case that NFA does not contain any states, this function does nothing. + * + * @param[in] alphabet Alphabet to use for computing "missing" symbols. If @c nullptr, use @c this->alphabet when + * defined, otherwise use @c this->delta.get_used_symbols(). + * @param[in] sink_state The state into which new transitions are added. If @c std::nullopt, add a new sink state. + * @return @c true if a new transition was added to the NFA. + */ + bool make_complete(const Alphabet* alphabet = nullptr, std::optional sink_state = std::nullopt); + + /** + * @brief Make NFA complete in place. + * + * For each state 0,...,this->num_of_states()-1, add transitions with "missing" symbols from @p alphabet + * (symbols that do not occur on transitions from given state) to @p sink_state. If @p sink_state does not belong + * to the NFA, it is added to it, but only in the case that some transition to @p sink_state was added. + * In the case that NFA does not contain any states, this function does nothing. + * + * This overloaded version is a more efficient version which does not need to compute the set of symbols to + * complete to from the alphabet. Prefer this version when you already have the set of symbols precomputed or plan + * to complete multiple automata over the same set of symbols. + * + * @param[in] symbols Symbols to compute "missing" symbols from. + * @param[in] sink_state The state into which new transitions are added. If @c std::nullopt, add a new sink state. + * @return @c true if a new transition was added to the NFA. + */ + bool make_complete(const utils::OrdVector& symbols, std::optional sink_state = std::nullopt); + + /** + * Complement deterministic automaton in-place by adding a sink state and swapping final and non-final states. + * @param[in] symbols Symbols needed to make the automaton complete. + * @param[in] sink_state State to be used as a sink state. Adds a new sink state when not specified. + * @return DFA complemented in-place. + * @pre @c this is a deterministic automaton. + */ + Cntnfa& complement_deterministic(const mata::utils::OrdVector& symbols, std::optional sink_state = std::nullopt); +}; // struct Cntnfa. + +// Allow variadic number of arguments of the same type. +// +// Using parameter pack and variadic arguments. +// Adapted from: https://www.fluentcpp.com/2019/01/25/variadic-number-function-parameters-type/. +/// Pack of bools for reasoning about a sequence of parameters. +template struct bool_pack{}; +/// Check that for all values in a pack @p Ts are 'true'. +template using conjunction = std::is_same, bool_pack>; +/// Check that all types in a sequence of parameters @p Ts are of type @p T. +template using AreAllOfType = typename conjunction...>::type; + +/** + * Create alphabet from variadic number of NFAs given as arguments. + * @tparam[in] Cntnfas Type Cntnfa. + * @param[in] nfas NFAs to create alphabet from. + * @return Created alphabet. + */ +template> +inline OnTheFlyAlphabet create_alphabet(const Cntnfas&... nfas) { + mata::OnTheFlyAlphabet alphabet{}; + auto f = [&alphabet](const Cntnfa& aut) { + aut.fill_alphabet(alphabet); + }; + (f(nfas), ...); + return alphabet; +} + +/** + * Create alphabet from a vector of NFAs. + * @param[in] nfas Vector of NFAs to create alphabet from. + * @return Created alphabet. + */ +OnTheFlyAlphabet create_alphabet(const std::vector>& nfas); + +/** + * Create alphabet from a vector of NFAs. + * @param[in] nfas Vector of NFAs to create alphabet from. + * @return Created alphabet. + */ +OnTheFlyAlphabet create_alphabet(const std::vector>& nfas); + +/** + * Create alphabet from a vector of NFAs. + * @param[in] nfas Vector of pointers to NFAs to create alphabet from. + * @return Created alphabet. + */ +OnTheFlyAlphabet create_alphabet(const std::vector& nfas); + +/** + * Create alphabet from a vector of NFAs. + * @param[in] nfas Vector of pointers to NFAs to create alphabet from. + * @return Created alphabet. + */ +OnTheFlyAlphabet create_alphabet(const std::vector& nfas); + +/** + * @brief Compute non-deterministic union of two counter NFAs. + * + * Counter NFAs are unnecessarily contain counters or annotations. + */ +Cntnfa union_nondet_counter_nfas(const Cntnfa &lhs, const Cntnfa &rhs); + +/** + * @brief Compute non-deterministic union of two NFAs (no counters or annotations). + * + * Does not add epsilon transitions, just unites initial and final states. + * @return Non-deterministic union of @p lhs and @p rhs. + */ +Cntnfa union_nondet(const Cntnfa &lhs, const Cntnfa &rhs); + +/** + * @brief Compute union by product construction. + * + * Preserves determinism. + * @param[in] first_epsilon The first symbol to handle as an epsilon. + * @param[out] prod_map Map mapping product states to the original states. + * @return Union by product construction of @p lhs and @p rhs. + */ +Cntnfa union_product(const Cntnfa &lhs, const Cntnfa &rhs, Symbol first_epsilon = EPSILON, + std::unordered_map,State> *prod_map = nullptr); + +/** + * @brief Compute a language difference as @p nfa_included \ @p nfa_excluded. + * + * Computed as a lazy intersection of @p nfa_included and a complement of @p nfa_excluded. The NFAs are lazily + * determinized and the complement is constructed lazily as well, guided by @p nfa_included. + * + * @param[in] nfa_included NFA to include in the difference. + * @param[in] nfa_excluded NFA to exclude from the difference. + * @param[in] macrostate_discover Callback event handler for discovering a new macrostate in the language difference + * automaton for the first time. Return @c true if the computation should continue, and @c false if the computation + * should stop and return only the NFA for the language difference constructed so far. + * The parameters are: + const Cntnfa& nfa_included, + const Cntnfa& nfa_excluded, + const StateSet& macrostate_included_state_set, + const StateSet& macrostate_excluded_state_set, + const State macrostate, + const Cntnfa& nfa_lang_difference. + * @todo: TODO: Add support for specifying first epsilon symbol and compute epsilon closure during determinization. + */ +Cntnfa lang_difference( + const Cntnfa &nfa_included, const Cntnfa &nfa_excluded, + std::optional< + std::function + > macrostate_discover = std::nullopt +); + +/** + * @brief Compute intersection of two counter NFAs. + */ +Cntnfa intersection_counter_nfas(const Cntnfa &lhs, const Cntnfa &rhs); + +/** + * @brief Compute intersection of two NFAs. + * + * Both automata can contain ε-transitions. The product preserves the ε-transitions, i.e., + * for each each product state `(s, t)` with`s -ε-> p`, `(s, t) -ε-> (p, t)` is created, and vice versa. + * + * Automata must share alphabets. //TODO: this is not implemented yet. + * + * @param[in] lhs First NFA to compute intersection for. + * @param[in] rhs Second NFA to compute intersection for. + * @param[in] first_epsilon smallest epsilon. //TODO: this should eventually be taken from the alphabet as anything larger than the largest symbol? + * @param[out] prod_map Mapping of pairs of the original states (lhs_state, rhs_state) to new product states (not used internally, allocated only when !=nullptr, expensive). + * @return NFA as a product of NFAs @p lhs and @p rhs with ε-transitions preserved. + */ +Cntnfa intersection(const Cntnfa& lhs, const Cntnfa& rhs, + const Symbol first_epsilon = EPSILON, std::unordered_map, State> *prod_map = nullptr); + +/** + * @brief Concatenate two NFAs. + * + * Supports epsilon symbols when @p use_epsilon is set to true. + * @param[in] lhs First automaton to concatenate. + * @param[in] rhs Second automaton to concatenate. + * @param[in] use_epsilon Whether to concatenate over epsilon symbol. + * @param[out] lhs_state_renaming Map mapping lhs states to result states. + * @param[out] rhs_state_renaming Map mapping rhs states to result states. + * @return Concatenated automaton. + */ +// TODO: check how fast is using just concatenate over epsilon and then call remove_epsilon(). +Cntnfa concatenate(const Cntnfa& lhs, const Cntnfa& rhs, bool use_epsilon = false, + StateRenaming* lhs_state_renaming = nullptr, StateRenaming* rhs_state_renaming = nullptr); + +/** + * @brief Compute automaton accepting complement of @p aut. + * + * @param[in] aut Automaton whose complement to compute. + * @param[in] alphabet Alphabet used for complementation. + * @param[in] params Optional parameters to control the complementation algorithm: + * - "algorithm": + * - "classical": The classical algorithm determinizes the automaton, makes it complete, and swaps final and + * non-final states. + * - "brzozowski": The Brzozowski algorithm determinizes the automaton using Brzozowski minimization, makes it + * complete, and swaps final and non-final states. + * @return Complemented automaton. + */ +Cntnfa complement(const Cntnfa& aut, const Alphabet& alphabet, const ParameterMap& params = { { "algorithm", "classical" } }); + +/** + * @brief Compute automaton accepting complement of @p aut. + * + * This overloaded version complements over an already created ordered set of @p symbols instead of an alphabet. + * This is a more efficient solution in case you already have @p symbols precomputed or want to complement multiple + * automata over the same set of @c symbols: the function does not need to compute the ordered set of symbols from + * the alphabet again (and for each automaton). + * + * @param[in] aut Automaton whose complement to compute. + * @param[in] symbols Symbols to complement over. + * @param[in] params Optional parameters to control the complementation algorithm: + * - "algorithm": + * - "classical": The classical algorithm determinizes the automaton, makes it complete, and swaps final and + * non-final states. + * - "brzozowski": The Brzozowski algorithm determinizes the automaton using Brzozowski minimization, makes it + * complete, and swaps final and non-final states. + * @return Complemented automaton. + */ +Cntnfa complement(const Cntnfa& aut, const utils::OrdVector& symbols, + const ParameterMap& params = { { "algorithm", "classical" } }); + +/** + * @brief Compute minimal deterministic automaton. + * + * @param[in] aut Automaton whose minimal version to compute. + * @param[in] params Optional parameters to control the minimization algorithm: + * - "algorithm": "brzozowski" + * @return Minimal deterministic automaton. + */ +Cntnfa minimize(const Cntnfa &aut, const ParameterMap& params = { { "algorithm", "brzozowski" } }); + +/** + * @brief Determinize automaton. + * + * @param[in] aut Automaton to determinize. + * @param[out] subset_map Map that maps sets of states of input automaton to states of determinized automaton. + * @param[in] macrostate_discover Callback event handler for discovering a new macrostate for the first time. The + * parameters are the determinized NFA constructed so far, the current macrostate, and the set of the original states + * corresponding to the macrostate. Return @c true if the determinization should continue, and @c false if the + * determinization should stop and return only the determinized NFA constructed so far. + * @return Determinized automaton. + * @todo: TODO: Add support for specifying first epsilon symbol and compute epsilon closure during determinization. + */ +Cntnfa determinize( + const Cntnfa& aut, std::unordered_map *subset_map = nullptr, + std::optional> macrostate_discover = std::nullopt); + +/** + * @brief Reduce the size of the automaton. + * + * @param[in] aut Automaton to reduce. + * @param[out] state_renaming Mapping of original states to reduced states. + * @param[in] params Optional parameters to control the reduction algorithm: + * - "algorithm": "simulation", "residual", + * and options to parametrize residual reduction, not utilized in simulation + * - "type": "after", "with", + * - "direction": "forward", "backward". + * @return Reduced automaton. + */ +Cntnfa reduce(const Cntnfa &aut, StateRenaming *state_renaming = nullptr, + const ParameterMap& params = {{ "algorithm", "simulation" }, { "type", "after" }, { "direction", "forward" } }); + +/** + * @brief Checks inclusion of languages of two NFAs: @p smaller and @p bigger (smaller <= bigger). + * + * @param[in] smaller First automaton to concatenate. + * @param[in] bigger Second automaton to concatenate. + * @param[out] cex Counterexample for the inclusion. + * @param[in] alphabet Alphabet of both NFAs to compute with. + * @param[in] params Optional parameters to control the equivalence check algorithm: + * - "algorithm": "naive", "antichains" (Default: "antichains") + * @return True if @p smaller is included in @p bigger, false otherwise. + */ +bool is_included(const Cntnfa& smaller, const Cntnfa& bigger, Run* cex, const Alphabet* alphabet = nullptr, + const ParameterMap& params = {{ "algorithm", "antichains" }}); + +/** + * @brief Checks inclusion of languages of two NFAs: @p smaller and @p bigger (smaller <= bigger). + * + * @param[in] smaller First automaton to concatenate. + * @param[in] bigger Second automaton to concatenate. + * @param[in] alphabet Alphabet of both NFAs to compute with. + * @param[in] params Optional parameters to control the equivalence check algorithm: + * - "algorithm": "naive", "antichains" (Default: "antichains") + * @return True if @p smaller is included in @p bigger, false otherwise. + */ +inline bool is_included(const Cntnfa& smaller, const Cntnfa& bigger, const Alphabet* const alphabet = nullptr, + const ParameterMap& params = {{ "algorithm", "antichains" }}) { + return is_included(smaller, bigger, nullptr, alphabet, params); +} + +/** + * @brief Perform equivalence check of two NFAs: @p lhs and @p rhs. + * + * @param[in] lhs First automaton to concatenate. + * @param[in] rhs Second automaton to concatenate. + * @param[in] alphabet Alphabet of both NFAs to compute with. + * @param[in] params[ Optional parameters to control the equivalence check algorithm: + * - "algorithm": "naive", "antichains" (Default: "antichains") + * @return True if @p lhs and @p rhs are equivalent, false otherwise. + */ +bool are_equivalent(const Cntnfa& lhs, const Cntnfa& rhs, const Alphabet* alphabet, + const ParameterMap& params = {{ "algorithm", "antichains"}}); + +/** + * @brief Perform equivalence check of two NFAs: @p lhs and @p rhs. + * + * The current implementation of @c Cntnfa does not accept input alphabet. For this reason, an alphabet + * has to be created from all transitions each time an operation on alphabet is called. When calling this function, + * the alphabet has to be computed first. + * + * Hence, this function is less efficient than its alternative taking already defined alphabet as its parameter. + * That way, alphabet has to be computed only once, as opposed to the current ad-hoc construction of the alphabet. + * The use of the alternative with defined alphabet should be preferred. + * + * @param[in] lhs First automaton to concatenate. + * @param[in] rhs Second automaton to concatenate. + * @param[in] params Optional parameters to control the equivalence check algorithm: + * - "algorithm": "naive", "antichains" (Default: "antichains") + * @return True if @p lhs and @p rhs are equivalent, false otherwise. + */ +bool are_equivalent(const Cntnfa& lhs, const Cntnfa& rhs, const ParameterMap& params = {{ "algorithm", "antichains"}}); + +// Reverting the automaton by one of the three functions below, +// currently simple_revert seems best (however, not tested enough). +Cntnfa revert(const Cntnfa& aut); + +// This revert algorithm is fragile, uses low level accesses to Cntnfa and static data structures, +// and it is potentially dangerous when there are used symbols with large numbers (allocates an array indexed by symbols) +// It is faster asymptotically and for somewhat dense automata, +// the same or a little bit slower than simple_revert otherwise. +// Not affected by pre-reserving vectors. +Cntnfa fragile_revert(const Cntnfa& aut); + +// Reverting the automaton by a simple algorithm, which does a lot of random access addition to Post and Move. +// Much affected by pre-reserving vectors. +Cntnfa simple_revert(const Cntnfa& aut); + +// Reverting the automaton by a modification of the simple algorithm. +// It replaces random access addition to SymbolPost by push_back and sorting later, so far seems the slowest of all, except on +// dense automata, where it is almost as slow as simple_revert. Candidate for removal. +Cntnfa somewhat_simple_revert(const Cntnfa& aut); + +// Removing epsilon transitions +Cntnfa remove_epsilon(const Cntnfa& aut, Symbol epsilon = EPSILON); + +/** Encodes a vector of strings (each corresponding to one symbol) into a + * @c Word instance + */ + // TODO: rename to something, but no idea to what. + // Maybe we need some terminology - Symbols and Words are made of numbers. + // What are the symbol names and their sequences? +Run encode_word(const Alphabet* alphabet, const std::vector& input); + +/** + * Get the set of symbols to work with during operations. + * @param[in] shared_alphabet Optional alphabet shared between NFAs passed as an argument to a function. + */ +utils::OrdVector get_symbols_to_work_with(const cntnfa::Cntnfa& nfa, const Alphabet* const shared_alphabet = nullptr); + +/** + * @brief Get any arbitrary accepted word in the language difference of @p nfa_included without @p nfa_excluded. + * + * The language difference automaton is lazily constructed without computing the whole determinized automata and the + * complememt of @p nfa_excluded. The algorithm returns an arbitrary word from the language difference constructed + * until the first macrostate with a final state in the original states in @p nfa_included and without any + * corresponding final states in @p nfa_excluded is encountered. + * + * @pre The automaton does not contain any epsilon transitions. + * @param[in] nfa_included NFA to include in the language difference. + * @param[in] nfa_excluded NFA to exclude in the language difference. + * TODO: Support lazy epsilon closure? + * @return An arbitrary word from the language difference, or @c std::nullopt if the language difference automaton + * is universal on the set of symbols from transitions of @p nfa_included. + */ +std::optional get_word_from_lang_difference(const Cntnfa &nfa_included, const Cntnfa &nfa_excluded); + +} // namespace mata::cntnfa. + +namespace std { +template <> +struct hash { + inline size_t operator()(const mata::cntnfa::Transition& trans) const { + size_t accum = std::hash{}(trans.source); + accum = mata::utils::hash_combine(accum, trans.symbol); + accum = mata::utils::hash_combine(accum, trans.target); + return accum; + } +}; + +std::ostream& operator<<(std::ostream& os, const mata::cntnfa::Transition& trans); +std::ostream& operator<<(std::ostream& os, const mata::cntnfa::Cntnfa& nfa); +} // namespace std. diff --git a/include/mata/cntnfa/delta.hh b/include/mata/cntnfa/delta.hh new file mode 100644 index 000000000..305ccdd8c --- /dev/null +++ b/include/mata/cntnfa/delta.hh @@ -0,0 +1,574 @@ +// TODO: Insert file header. + +#pragma once + +#include + +#include "mata/utils/sparse-set.hh" +#include "mata/utils/synchronized-iterator.hh" +#include "mata/alphabet.hh" +#include "mata/cntnfa/types.hh" +#include "mata/cntnfa/annotations.hh" + +namespace mata::cntnfa { + +/// A single transition in Delta represented as a triple(source, symbol, target). +struct Transition { + State source; ///< Source state. + Symbol symbol; ///< Transition symbol. + Target target; ///< Target state. + + Transition() : source(), symbol(), target() { } + Transition(const Transition&) = default; + Transition(Transition&&) = default; + Transition &operator=(const Transition&) = default; + Transition &operator=(Transition&&) = default; + Transition(const State source, const Symbol symbol, const Target target) + : source(source), symbol(symbol), target(target) {} + + auto operator<=>(const Transition&) const = default; +}; + +/** + * Move from a @c StatePost for a single source state, represented as a pair of @c symbol and target state @c target. + */ +class Move { +public: + Symbol symbol; + Target target; + + bool operator==(const Move&) const = default; +}; // class Move. + +/** + * Structure represents a post of a single @c symbol: a set of target states in transitions. + * + * A set of @c SymbolPost, called @c StatePost, is describing the automata transitions from a single source state. + */ +class SymbolPost { +public: + Symbol symbol{}; + TargetSet targets{}; // Note: Changed StateSet to TargetSet (CounterStateSet). + + SymbolPost() = default; + explicit SymbolPost(Symbol symbol) : symbol{ symbol }, targets{} {} + + SymbolPost(Symbol symbol, Target target) : symbol{ symbol }, targets{ target } {} + SymbolPost(Symbol symbol, TargetSet targets) : symbol{ symbol }, targets{ std::move(targets) } {} + SymbolPost(Symbol symbol, State state_to) : symbol{ symbol }, targets{ state_to } {} + SymbolPost(Symbol symbol, StateSet states_to) : symbol{ symbol }, targets{ std::move(states_to) } {} + + SymbolPost(SymbolPost&& rhs) noexcept : symbol{ rhs.symbol }, targets{ std::move(rhs.targets) } {} + SymbolPost(const SymbolPost& rhs) = default; + SymbolPost& operator=(SymbolPost&& rhs) noexcept; + SymbolPost& operator=(const SymbolPost& rhs) = default; + + std::weak_ordering operator<=>(const SymbolPost& other) const { return symbol <=> other.symbol; } + bool operator==(const SymbolPost& other) const { return symbol == other.symbol; } + + TargetSet::iterator begin() { return targets.begin(); } + TargetSet::iterator end() { return targets.end(); } + + TargetSet::const_iterator cbegin() const { return targets.cbegin(); } + TargetSet::const_iterator cend() const { return targets.cend(); } + + size_t count(State s) const { return targets.count(s); } + bool empty() const { return targets.empty(); } + size_t num_of_targets() const { return targets.size(); } + + void insert(State s); + void insert(const StateSet& states); + + // THIS BREAKS THE SORTEDNESS INVARIANT, + // dangerous, + // but useful for adding states in a random order to sort later (supposedly more efficient than inserting in a random order) + void inline push_back(const State s) { targets.push_back(s); } + + template + StateSet& emplace_back(Args&&... args) { + // Forwardinng the variadic template pack of arguments to the emplace_back() of the underlying container. + return targets.emplace_back(std::forward(args)...); + } + + void erase(State s) { targets.erase(s); } + + std::vector::const_iterator find(State s) const { return targets.find(s); } + std::vector::iterator find(State s) { return targets.find(s); } +}; // class mata::cntnfa::SymbolPost. + +/** + * @brief A data structure representing possible transitions over different symbols from a source state. + * + * It is an ordered vector containing possible @c SymbolPost (i.e., pair of symbol and target states). + * @c SymbolPosts in the vector are ordered by symbols in @c SymbolPosts. + */ +class StatePost : private utils::OrdVector { +private: + using super = utils::OrdVector; +public: + using super::iterator, super::const_iterator; + using super::begin, super::end, super::cbegin, super::cend; + using super::OrdVector; + using super::operator=; + using super::operator==; + StatePost(const StatePost&) = default; + StatePost(StatePost&&) = default; + StatePost& operator=(const StatePost&) = default; + StatePost& operator=(StatePost&&) = default; + bool operator==(const StatePost&) const = default; + using super::insert; + using super::reserve; + using super::empty, super::size; + using super::to_vector; + // dangerous, breaks the sortedness invariant + using super::emplace_back; + // dangerous, breaks the sortedness invariant + using super::push_back; + // is adding non-const version as well ok? + using super::back; + using super::pop_back; + using super::filter; + + using super::erase; + + using super::find; + iterator find(const Symbol symbol) { return super::find({ symbol, {} }); } + const_iterator find(const Symbol symbol) const { return super::find({ symbol, {} }); } + + ///returns an iterator to the smallest epsilon, or end() if there is no epsilon + const_iterator first_epsilon_it(Symbol first_epsilon) const; + + + /** + * @brief Iterator over moves represented as @c Move instances. + * + * It iterates over pairs (symbol, target) for the given @c StatePost. + */ + class Moves { + public: + Moves() = default; + /** + * @brief construct moves iterating over a range @p symbol_post_it (including) to @p symbol_post_end (excluding). + * + * @param[in] state_post State post to iterate over. + * @param[in] symbol_post_it First iterator over symbol posts to iterate over. + * @param[in] symbol_post_end End iterator over symbol posts (which functions as an sentinel; is not iterated over). + */ + Moves(const StatePost& state_post, StatePost::const_iterator symbol_post_it, StatePost::const_iterator symbol_post_end); + Moves(Moves&&) = default; + Moves(Moves&) = default; + Moves& operator=(Moves&& other) noexcept; + Moves& operator=(const Moves& other) noexcept; + + class const_iterator; + const_iterator begin() const; + const_iterator end() const; + + private: + const StatePost* state_post_{ nullptr }; + StatePost::const_iterator symbol_post_it_{}; ///< Current symbol post iterator to iterate over. + /// End symbol post iterator which is no longer iterated over (one after the last symbol post iterated over or + /// end()). + StatePost::const_iterator symbol_post_end_{}; + }; // class Moves. + + /** + * Iterator over all moves (over all labels) in @c StatePost represented as @c Move instances. + */ + Moves moves() const { return { *this, this->cbegin(), this->cend() }; } + /** + * Iterator over specified moves in @c StatePost represented as @c Move instances. + * + * @param[in] symbol_post_it First iterator over symbol posts to iterate over. + * @param[in] symbol_post_end End iterator over symbol posts (which functions as an sentinel, is not iterated over). + */ + Moves moves(StatePost::const_iterator symbol_post_it, StatePost::const_iterator symbol_post_end) const; + /** + * Iterator over epsilon moves in @c StatePost represented as @c Move instances. + */ + Moves moves_epsilons(Symbol first_epsilon = EPSILON) const; + /** + * Iterator over alphabet (normal) symbols (not over epsilons) in @c StatePost represented as @c Move instances. + */ + Moves moves_symbols(Symbol last_symbol = EPSILON - 1) const; + + /** + * Count the number of all moves in @c StatePost. + */ + size_t num_of_moves() const; +}; // class StatePost. + +/** + * Iterator over moves. + */ +class StatePost::Moves::const_iterator { +private: + const StatePost* state_post_{ nullptr }; + StatePost::const_iterator symbol_post_it_{}; + TargetSet::const_iterator target_it_{}; // Note: Changed to TargetSet instead of StateSet. + StatePost::const_iterator symbol_post_end_{}; + bool is_end_{ false }; + /// Internal allocated instance of @c Move which is set for the move currently iterated over and returned as + /// a reference with @c operator*(). + Move move_{}; + +public: + using iterator_category = std::forward_iterator_tag; + using value_type = Move; + using difference_type = size_t; + using pointer = Move*; + using reference = Move&; + + /// Construct end iterator. + const_iterator(): is_end_{ true } {} + /// Const all moves iterator. + const_iterator(const StatePost& state_post); + /// Construct iterator from @p symbol_post_it (including) to @p symbol_post_it_end (excluding). + const_iterator(const StatePost& state_post, StatePost::const_iterator symbol_post_it, + StatePost::const_iterator symbol_post_it_end); + const_iterator(const const_iterator& other) noexcept = default; + const_iterator(const_iterator&&) = default; + + const Move& operator*() const { return move_; } + const Move* operator->() const { return &move_; } + + // Prefix increment + const_iterator& operator++(); + // Postfix increment + const const_iterator operator++(int); + + const_iterator& operator=(const const_iterator& other) noexcept = default; + const_iterator& operator=(const_iterator&&) = default; + + bool operator==(const const_iterator& other) const; +}; // class const_iterator. + +/** + * @brief Specialization of utils::SynchronizedExistentialIterator for iterating over SymbolPosts. + */ +class SynchronizedExistentialSymbolPostIterator : public utils::SynchronizedExistentialIterator::const_iterator> { +public: + /** + * @brief Get union of all targets. + */ + StateSet unify_targets() const; + + /** + * @brief Synchronize with the given SymbolPost @p sync. + * + * Alignes the synchronized iterator to the same symbol as @p sync. + * @return True iff the synchronized iterator points to the same symbol as @p sync. + */ + bool synchronize_with(const SymbolPost& sync); + + /** + * @brief Synchronize with the given symbol @p sync_symbol. + * + * Alignes the synchronized iterator to the same symbol as @p sync_symbol. + * @return True iff the synchronized iterator points to the same symbol as @p sync. + */ + bool synchronize_with(Symbol sync_symbol); +}; // class SynchronizedExistentialSymbolPostIterator. + +/** + * @brief Delta is a data structure for representing transition relation. + * + * Transition is represented as a triple Trans(source state, symbol, target state). Move is the part (symbol, target + * state), specified for a single source state. + * Its underlying data structure is vector of StatePost classes. Each index to the vector corresponds to one source + * state, that is, a number for a certain state is an index to the vector of state posts. + * Transition relation (delta) in Mata stores a set of transitions in a four-level hierarchical structure: + * Delta, StatePost, SymbolPost, and a set of target states. + * A vector of 'StatePost's indexed by a source states on top, where the StatePost for a state 'q' (whose number is + * 'q' and it is the index to the vector of 'StatePost's) stores a set of 'Move's from the source state 'q'. + * Namely, 'StatePost' has a vector of 'SymbolPost's, where each 'SymbolPost' stores a symbol 'a' and a vector of + * target states of 'a'-moves from state 'q'. 'SymbolPost's are ordered by the symbol, target states are ordered by + * the state number. + */ +class Delta { +public: + inline static const StatePost empty_state_post; // When posts[q] is not allocated, then delta[q] returns this. + + Delta(): state_posts_{} {} + Delta(const Delta& other) = default; + Delta(Delta&& other) = default; + explicit Delta(size_t n): state_posts_{ n } {} + + Delta& operator=(const Delta& other) = default; + Delta& operator=(Delta&& other) = default; + + bool operator==(const Delta& other) const; + + void reserve(size_t n) { + state_posts_.reserve(n); + }; + + /** + * @brief Get constant reference to the state post of @p src_state. + * + * If we try to access a state post of a @p src_state which is present in the automaton as an initial/final state, + * yet does not have allocated space in @c Delta, an @c empty_post is returned. Hence, the function has no side + * effects (no allocation is performed; iterators remain valid). + * @param state_from[in] Source state of a state post to access. + * @return State post of @p src_state. + */ + const StatePost& state_post(const State src_state) const { + if (src_state >= num_of_states()) { + return empty_state_post; + } + return state_posts_[src_state]; + } + + /** + * @brief Get constant reference to the state post of @p src_state. + * + * If we try to access a state post of a @p src_state which is present in the automaton as an initial/final state, + * yet does not have allocated space in @c Delta, an @c empty_post is returned. Hence, the function has no side + * effects (no allocation is performed; iterators remain valid). + * @param state_from[in] Source state of a state post to access. + * @return State post of @p src_state. + */ + const StatePost& operator[](State src_state) const { return state_post(src_state); } + + /** + * @brief Get mutable (non-constant) reference to the state post of @p src_state. + * + * The function allows modifying the state post. + * + * BEWARE, IT HAS A SIDE EFFECT. + * + * If we try to access a state post of a @p src_state which is present in the automaton as an initial/final state, + * yet does not have allocated space in @c Delta, a new state post for @p src_state will be allocated along with + * all state posts for all previous states. This in turn may cause that the entire post data structure is + * re-allocated. Iterators to @c Delta will get invalidated. + * Use the constant 'state_post()' is possible. Or, to prevent the side effect from causing issues, one might want + * to make sure that posts of all states in the automaton are allocated, e.g., write an NFA method that allocate + * @c Delta for all states of the NFA. + * @param state_from[in] Source state of a state post to access. + * @return State post of @p src_state. + */ + StatePost& mutable_state_post(State src_state); + + void defragment(const BoolVector& is_staying, const std::vector& renaming); + + template + StatePost& emplace_back(Args&&... args) { + // Forwarding the variadic template pack of arguments to the emplace_back() of the underlying container. + return state_posts_.emplace_back(std::forward(args)...); + } + + void clear() { state_posts_.clear(); } + + /** + * @brief Allocate state posts up to @p num_of_states states, creating empty @c StatePost for yet unallocated state + * posts. + * + * @param[in] num_of_states Number of states in @c Delta to allocate state posts for. Have to be at least + * num_of_states() + 1. + */ + void allocate(const size_t num_of_states) { + assert(num_of_states >= this->num_of_states()); + state_posts_.resize(num_of_states); + } + + /** + * @return Number of states in the whole Delta, including both source and target states. + */ + size_t num_of_states() const { return state_posts_.size(); } + + /** + * Check whether the @p state is used in @c Delta. + */ + bool uses_state(const State state) const { return state < num_of_states(); } + + /** + * @return Number of transitions in Delta. + */ + size_t num_of_transitions() const; + + void add(State source, Symbol symbol, Target target); + void add(State source, Symbol symbol, State target); + void add(const Transition& transition) { add(transition.source, transition.symbol, transition.target); } + + void remove(State source, Symbol symbol, Target target); + void remove(const Transition& transition) { remove(transition.source, transition.symbol, transition.target); } + + /** + * Check whether @c Delta contains a passed transition. + */ + bool contains(State source, Symbol symbol, Target target) const; + + /** + * Check whether @c Delta contains a transition passed as a triple. + */ + bool contains(const Transition& transition) const; + + /** + * Check whether automaton contains no transitions. + * @return True if there are no transitions in the automaton, false otherwise. + */ + bool empty() const; + + /** + * @brief Append post vector to the delta. + * + * @param post_vector Vector of posts to be appended. + */ + void append(const std::vector& post_vector); + + /** + * @brief Append with remapped states and annotations. + */ + void append_remapped(const Delta& other, State state_offset, size_t annotation_set_offset); + + /** + * @brief Copy posts of delta and apply a lambda update function on each state from + * targets. + * + * IMPORTANT: In order to work properly, the lambda function needs to be + * monotonic, that is, the order of states in targets cannot change. + * + * @param target_renumberer Monotonic lambda function mapping states to different states. + * @return std::vector Copied posts. + */ + std::vector renumber_targets(const std::function& target_renumberer) const; + + /** + * @brief Add transitions to multiple destinations + * + * @param source Source state + * @param symbol Transition symbol + * @param targets Set of target states + */ + void add(const State source, const Symbol symbol, const TargetSet& targets); + void add(const State source, const Symbol symbol, const StateSet& targets); + + using const_iterator = std::vector::const_iterator; + const_iterator cbegin() const { return state_posts_.cbegin(); } + const_iterator cend() const { return state_posts_.cend(); } + const_iterator begin() const { return state_posts_.begin(); } + const_iterator end() const { return state_posts_.end(); } + + class Transitions; + + /** + * Iterator over transitions represented as @c Transition instances. + */ + Transitions transitions() const; + + /** + * Get transitions leading to @p state_to. + * @param state_to[in] Target state for transitions to get. + * @return Transitions leading to @p state_to. + * + * Operation is slow, traverses over all symbol posts. + */ + std::vector get_transitions_to(State state_to) const; + + /** + * Iterate over @p epsilon symbol posts under the given @p state. + * @param[in] state State from which epsilon transitions are checked. + * @param[in] epsilon User can define his favourite epsilon or used default. + * @return An iterator to @c SymbolPost with epsilon symbol. End iterator when there are no epsilon transitions. + */ + StatePost::const_iterator epsilon_symbol_posts(State state, Symbol epsilon = EPSILON) const; + + /** + * Iterate over @p epsilon symbol posts under the given @p state_post. + * @param[in] state_post State post from which epsilon transitions are checked. + * @param[in] epsilon User can define his favourite epsilon or used default. + * @return An iterator to @c SymbolPost with epsilon symbol. End iterator when there are no epsilon transitions. + */ + static StatePost::const_iterator epsilon_symbol_posts(const StatePost& state_post, Symbol epsilon = EPSILON); + + /** + * @brief Expand @p target_alphabet by symbols from this delta. + * + * The value of the already existing symbols will NOT be overwritten. + */ + void add_symbols_to(OnTheFlyAlphabet& target_alphabet) const; + + /** + * @brief Get the set of symbols used on the transitions in the automaton. + * + * Does not necessarily have to equal the set of symbols in the alphabet used by the automaton. + * @return Set of symbols used on the transitions. + */ + utils::OrdVector get_used_symbols() const; + + utils::OrdVector get_used_symbols_vec() const; + std::set get_used_symbols_set() const; + utils::SparseSet get_used_symbols_sps() const; + std::vector get_used_symbols_bv() const; + BoolVector get_used_symbols_chv() const; + + /** + * @brief Get the maximum non-epsilon used symbol. + */ + Symbol get_max_symbol() const; +private: + std::vector state_posts_; +}; // class Delta. + +/** + * @brief Iterator over transitions represented as @c Transition instances. + * + * It iterates over triples (State source, Symbol symbol, Target target). + */ +class Delta::Transitions { +public: + Transitions() = default; + explicit Transitions(const Delta* delta): delta_{ delta } {} + Transitions(Transitions&&) = default; + Transitions(Transitions&) = default; + Transitions& operator=(Transitions&&) = default; + Transitions& operator=(Transitions&) = default; + + class const_iterator; + const_iterator begin() const; + const_iterator end() const; +private: + const Delta* delta_; +}; // class Transitions. + +/** + * Iterator over transitions. + */ +class Delta::Transitions::const_iterator { +private: + const Delta* delta_ = nullptr; + size_t current_state_{}; + StatePost::const_iterator state_post_it_{}; + TargetSet::const_iterator symbol_post_it_{}; // Note: Changed to TargetSet instead of StateSet. + bool is_end_{ false }; + Transition transition_{}; + +public: + using iterator_category = std::forward_iterator_tag; + using value_type = Transition; + using difference_type = size_t; + using pointer = Transition*; + using reference = Transition&; + + const_iterator(): is_end_{ true } {} + explicit const_iterator(const Delta& delta); + const_iterator(const Delta& delta, State current_state); + + const_iterator(const const_iterator& other) noexcept = default; + const_iterator(const_iterator&&) = default; + + const Transition& operator*() const { return transition_; } + const Transition* operator->() const { return &transition_; } + + // Prefix increment + const_iterator& operator++(); + // Postfix increment + const const_iterator operator++(int); + + const_iterator& operator=(const const_iterator& other) noexcept = default; + const_iterator& operator=(const_iterator&&) = default; + + bool operator==(const const_iterator& other) const; +}; // class Delta::Transitions::const_iterator. + +} // namespace mata::cntnfa. diff --git a/include/mata/cntnfa/plumbing.hh b/include/mata/cntnfa/plumbing.hh new file mode 100644 index 000000000..797281a15 --- /dev/null +++ b/include/mata/cntnfa/plumbing.hh @@ -0,0 +1,93 @@ +/* nfa-plumbings.hh -- Wrapping up different supporting functions. + */ + +#pragma once + +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/builder.hh" + +using namespace mata::cntnfa::builder; + +/** + * Simplified NFA API, used in binding to call NFA algorithms. + * + * In particular, this mostly includes operations and checks, that do not return Automaton, + * but instead take resulting automaton as pointer (e.g. `void f(Cntnfa* result, const Cntnfa& lhs, const Cntnfa& rhs)`). + */ +namespace mata::cntnfa::plumbing { + +inline void get_elements(StateSet* element_set, const BoolVector& bool_vec) { + element_set->clear(); + element_set->reserve(bool_vec.count()); + for (size_t i{ 0 }; i < bool_vec.size(); ++i) { + if (bool_vec[i] == 1) { + element_set->push_back(i); + } + } +} + +inline void complement( + Cntnfa* result, + const Cntnfa& aut, + const Alphabet& alphabet, + const ParameterMap& params = {{ "algorithm", "classical"}, + { "minimize", "false"}}) { *result = complement(aut, alphabet, params); +} + +inline void minimize(Cntnfa* res, const Cntnfa &aut) { *res = minimize(aut); } + +inline void determinize(Cntnfa* result, const Cntnfa& aut, std::unordered_map *subset_map = nullptr) { + *result = determinize(aut, subset_map); +} + +inline void reduce(Cntnfa* result, const Cntnfa &aut, StateRenaming *state_renaming = nullptr, + const ParameterMap& params = {{ "algorithm", "simulation"}}) { + *result = reduce(aut, state_renaming, params); +} + +inline void revert(Cntnfa* result, const Cntnfa& aut) { *result = revert(aut); } + +inline void remove_epsilon(Cntnfa* result, const Cntnfa& aut, Symbol epsilon = EPSILON) { *result = remove_epsilon(aut, epsilon); } + +/** Loads an automaton from Parsed object */ +template +void construct(Cntnfa* result, const ParsedObject& parsed, Alphabet* alphabet = nullptr, + NameStateMap* state_map = nullptr) { + OnTheFlyAlphabet tmp_alphabet{}; + if (!alphabet) { alphabet = &tmp_alphabet; } + *result = builder::construct(parsed, alphabet, state_map); +} + +inline void union_nondet(Cntnfa *unionAutomaton, const Cntnfa &lhs, const Cntnfa &rhs) { *unionAutomaton = union_nondet(lhs, rhs); } + +/** + * @brief Compute intersection of two NFAs. + * + * Both automata can contain ε-transitions. The product preserves the ε-transitions, i.e., + * for each each product state `(s, t)` with`s -ε-> p`, `(s, t) -ε-> (p, t)` is created, and vice versa. + * + * Automata must share alphabets. + * + * @param[out] res The resulting intersection NFA. + * @param[in] lhs Input NFA. + * @param[in] rhs Input NFA. + * @param[in] first_epsilon smallest epsilon. + * @param[out] prod_map Mapping of pairs of the original states (lhs_state, rhs_state) to new product states (not used internally, allocated only when !=nullptr, expensive). + * @return NFA as a product of NFAs @p lhs and @p rhs with ε-transitions preserved. + */ +inline void intersection(Cntnfa* res, const Cntnfa& lhs, const Cntnfa& rhs, Symbol first_epsilon = EPSILON, + std::unordered_map, State> *prod_map = nullptr) { + *res = intersection(lhs, rhs, first_epsilon, prod_map); +} + +/** + * @brief Concatenate two NFAs. + * @param[out] lhs_result_state_renaming Map mapping lhs states to result states. + * @param[out] rhs_result_state_renaming Map mapping rhs states to result states. + */ +inline void concatenate(Cntnfa* res, const Cntnfa& lhs, const Cntnfa& rhs, bool use_epsilon = false, + StateRenaming* lhs_result_state_renaming = nullptr, StateRenaming* rhs_result_state_renaming = nullptr) { + *res = concatenate(lhs, rhs, use_epsilon, lhs_result_state_renaming, rhs_result_state_renaming); +} + +} // namespace mata::cntnfa::Plumbing. diff --git a/include/mata/cntnfa/registers.hh b/include/mata/cntnfa/registers.hh new file mode 100644 index 000000000..09396bdfd --- /dev/null +++ b/include/mata/cntnfa/registers.hh @@ -0,0 +1,91 @@ +// TODO: Insert file header. + +#pragma once + +#include +#include +#include + +namespace mata::cntnfa { + +using RegisterValue = int; +using RegisterName = std::string; + +/// Register with operations. +struct Register { + RegisterValue value; ///< Current register value. + RegisterValue initial_value; ///< Initial register value. + RegisterName name; ///< Name of the register. + + Register() : value(0), initial_value(0), name() {} + Register(RegisterValue value, RegisterName name) + : value(value), initial_value(value), name(name) {} + + Register(const Register&) = default; + Register(Register&&) = default; + Register& operator=(const Register&) = default; + Register& operator=(Register&&) = default; + + Register& operator=(RegisterValue other) { value = other; return *this; } + + auto operator<=>(const RegisterValue& other) const { return value <=> other; } + auto operator<=>(const Register&) const = default; + + operator RegisterValue() const { return value; } + + // Increment the register value by 1 (or specified value). + void increment(RegisterValue value = 1); + + // Decrement the register value by 1 (or specified value). + void decrement(RegisterValue value = 1); + + // Set the register value to a specific value. + void set(RegisterValue value); + + // Reset the register to its initial value. + void reset(); +}; + +/// Set of registers. +class RegisterSet { +private: + std::vector counters; ///< Stores registers. + std::unordered_map name_to_index; ///< Maps register name to its index. + +public: + RegisterSet() : counters(), name_to_index() {} + + RegisterSet copy() const { + RegisterSet copy = *this; + return copy; + } + + bool operator==(const RegisterSet& other) const { + return counters == other.counters; + } + + Register& operator[](size_t id) { return counters[id]; } + const Register& operator[](size_t id) const { return counters[id]; } + RegisterValue get_value(size_t index) const { return counters[index].value; } + + void reserve(const size_t n); + + void allocate(const size_t new_size); + + size_t size() const; + + void clear(); + + void set(size_t index, const Register& counter); + size_t add(const RegisterName& name, RegisterValue value = 0); + size_t add_with_prefix(const std::string& prefix, RegisterValue value = 0); + + bool has(const RegisterName& name) const; + const RegisterName& get_name(size_t index) const; + std::vector get_names() const; + size_t get_index(const RegisterName& name) const; + + const Register& get(size_t index) const; +}; + +} // namespace mata::cntnfa. diff --git a/include/mata/cntnfa/strings.hh b/include/mata/cntnfa/strings.hh new file mode 100644 index 000000000..3ed33e8b5 --- /dev/null +++ b/include/mata/cntnfa/strings.hh @@ -0,0 +1,408 @@ +/* cntnfa-strings.hh -- Operations on NFAs for string solving. + */ + +#pragma once + +#include + +#include "mata/alphabet.hh" +#include "mata/cntnfa/delta.hh" +#include "mata/cntnfa/types.hh" +#include "mata/cntnfa/cntnfa.hh" + +/** + * NFA algorithms usable for solving string constraints. + */ +namespace mata::strings { + +using Cntnfa = cntnfa::Cntnfa; +using State = cntnfa::State; +using StateSet = cntnfa::StateSet; +using Transition = cntnfa::Transition; +using ParameterMap = cntnfa::ParameterMap; +using SymbolPost = cntnfa::SymbolPost; + +/** + * Class mapping states to the shortest words accepted by languages of the states. + */ +class ShortestWordsMap { +public: + /** + * Maps states in the automaton @p aut to shortest words accepted by languages of the states. + * @param aut Automaton to compute shortest words for. + */ + explicit ShortestWordsMap(const Cntnfa& aut) : reversed_automaton(revert(aut)) { + insert_initial_lengths(); + compute(); + } + + /** + * Gets shortest words for the given @p states. + * @param[in] states States to map shortest words for. + * @return Set of shortest words. + */ + std::set get_shortest_words_from(const StateSet& states) const; + + /** + * Gets shortest words for the given @p state. + * @param[in] state State to map shortest words for. + * @return Set of shortest words. + */ + std::set get_shortest_words_from(State state) const; + +private: + using WordLength = int; ///< A length of a word. + /// Pair binding the length of all words in the word set and word set with words of the given length. + using LengthWordsPair = std::pair>; + /// Map mapping states to the shortest words accepted by the automaton from the mapped state. + std::unordered_map shortest_words_map{}; + std::set processed{}; ///< Set of already processed states. + std::deque fifo_queue{}; ///< FIFO queue for states to process. + const Cntnfa reversed_automaton; ///< Reversed input automaton. + + /** + * @brief Inserts initial lengths into the shortest words map. + * + * Inserts initial length of length 0 for final state in the automaton (initial states in the reversed automaton). + */ + void insert_initial_lengths(); + + /** + * Computes shortest words for all states in the automaton. + */ + void compute(); + + /** + * Computes shortest words for the given @p state. + * @param[in] state State to compute shortest words for. + */ + void compute_for_state(State state); + + /** + * Creates default shortest words mapping for yet unprocessed @p state. + * @param[in] state State to map default shortest words. + * @return Created default shortest words map element for the given @p state. + */ + LengthWordsPair map_default_shortest_words(const State state) { + return shortest_words_map.emplace(state, std::make_pair(-1, std::set{})).first->second; + } + + /** + * Update words for the current state. + * @param[out] act Current state shortest words and length. + * @param[in] dst Transition target state shortest words and length. + * @param[in] symbol Symbol to update with. + */ + static void update_current_words(LengthWordsPair& act, const LengthWordsPair& dst, Symbol symbol); +}; // Class ShortestWordsMap. + +/** + * Get shortest words (regarding their length) of the automaton using BFS. + * @return Set of shortest words. + */ +std::set get_shortest_words(const Cntnfa& nfa); + +/** + * @brief Get all the one symbol words accepted by @p nfa. + */ +std::set get_accepted_symbols(const Cntnfa& nfa); + +/** + * @brief Get the lengths of all words in the automaton @p aut. The function returns a set of pairs where for each + * such a pair there is a word with length u+k*v for all ks. The disjunction of such formulae of all pairs hence precisely + * describe lengths of all words in the automaton. + * + * @param aut Input automaton + * @return Set of pairs describing lengths + */ +std::set> get_word_lengths(const Cntnfa& aut); + +/** + * @brief Checks if the automaton @p nfa accepts only a single word \eps. + * + * @param nfa Input automaton + * @return true iff L(nfa) = {\eps} + */ +bool is_lang_eps(const Cntnfa& nfa); + +/** + * Segment Automata including structs and algorithms. + * + * These are automata whose state space can be split into several segments connected by ε-transitions in a chain. + * No other ε-transitions are allowed. As a consequence, no ε-transitions can appear in a cycle. + * Segment automaton can have initial states only in the first segment and final states only in the last segment. + */ +namespace seg_cntnfa { + +using SegCntnfa = Cntnfa; +using VisitedEpsMap = std::map>; + +/// Number of visited epsilons. +using VisitedEpsilonsCounterMap = std::map; +/// Projection of VisitedEpsilonsNumberMap to sorted keys (in descending order). +using VisitedEpsilonsCounterVector = std::vector; + +/** +* Class executing segmentation operations for a given segment automaton. Works only with segment automata. +*/ +class Segmentation { +public: + using EpsilonDepth = size_t; ///< Depth of ε-transitions. + /// Dictionary of lists of ε-transitions grouped by their depth. + /// For each depth 'i' we have 'depths[i]' which contains a list of ε-transitions of depth 'i'. + using EpsilonDepthTransitions = std::unordered_map>; + using EpsilonDepthTransitionMap = std::unordered_map>>; + + /** + * Prepare automaton @p aut for segmentation. + * @param[in] aut Segment automaton to make segments for. + * @param[in] epsilon Symbol to execute segmentation for. + */ + explicit Segmentation(const SegCntnfa& aut, const std::set& epsilons) : epsilons(epsilons), automaton(aut) { + compute_epsilon_depths(); // Map depths to epsilon transitions. + } + + /** + * Get segmentation depths for ε-transitions. + * @return Map of depths to lists of ε-transitions. + */ + const EpsilonDepthTransitions& get_epsilon_depths() const { return epsilon_depth_transitions; } + + /** + * Get the epsilon depth trans map object (mapping of depths and states to eps-successors) + * + * @return Map of depths to a map of states to transitions + */ + const EpsilonDepthTransitionMap& get_epsilon_depth_trans_map() const { return this->eps_depth_trans_map; } + + /** + * Get segment automata. + * @return A vector of segments for the segment automaton in the order from the left (initial state in segment automaton) + * to the right (final states of segment automaton). + */ + const std::vector& get_segments(); + + /** + * Get raw segment automata. + * @return A vector of segments for the segment automaton in the order from the left (initial state in segment automaton) + * to the right (final states of segment automaton) without trimming (the states are same as in the original automaton). + */ + const std::vector& get_untrimmed_segments(); + + const VisitedEpsMap& get_visited_eps() const { return this->visited_eps; } + +private: + const std::set epsilons; ///< Symbol for which to execute segmentation. + /// Automaton to execute segmentation for. Must be a segment automaton (can be split into @p segments). + const SegCntnfa& automaton; + EpsilonDepthTransitions epsilon_depth_transitions{}; ///< Epsilon depths. + EpsilonDepthTransitionMap eps_depth_trans_map{}; /// Epsilon depths with mapping of states to epsilon transitions + std::vector segments{}; ///< Segments for @p automaton. + std::vector segments_raw{}; ///< Raw segments for @p automaton. + VisitedEpsMap visited_eps{}; /// number of visited eps for each state + + /** + * Pair of state and its depth. + */ + struct StateDepthTuple { + State state; ///< State with a depth. + EpsilonDepth depth; ///< Depth of a state. + VisitedEpsilonsCounterMap eps; /// visited epsilons and their numbers + }; + + /** + * Compute epsilon depths with their transitions. + */ + void compute_epsilon_depths(); + + /** + * Split segment @c automaton into @c segments. + */ + void split_aut_into_segments(); + + /** + * Propagate changes to the current segment automaton to the next segment automaton. + * @param[in] current_depth Current depth. + * @param[in] transition Current epsilon transition. + */ + void update_next_segment(size_t current_depth, const Transition& transition); + + /** + * Update current segment automaton. + * @param[in] current_depth Current depth. + * @param[in] transition Current epsilon transition. + */ + void update_current_segment(size_t current_depth, const Transition& transition); + + /** + * Initialize map of visited states. + * @return Map of visited states. + */ + std::unordered_map initialize_visited_map() const; + + /** + * Initialize worklist of states with depths to process. + * @return Queue of state and its depth pairs. + */ + std::deque initialize_worklist() const; + + /** + * Process pair of state and its depth. + * @param[in] state_depth_pair Current state depth pair. + * @param[out] worklist Worklist of state and depth pairs to process. + */ + void process_state_depth_pair(const StateDepthTuple& state_depth_pair, std::deque& worklist); + + /** + * Add states with non-epsilon transitions to the @p worklist. + * @param move[in] Move from current state. + * @param depth[in] Current depth. + * @param worklist[out] Worklist of state and depth pairs to process. + */ + void add_transitions_to_worklist(const StateDepthTuple& state_depth_pair, const SymbolPost& move, + std::deque& worklist); + + /** + * Process epsilon transitions for the current state. + * @param[in] state_depth_pair Current state depth pair. + * @param[in] move Move from current state. + * @param[out] worklist Worklist of state and depth pairs to process. + */ + void handle_epsilon_transitions(const StateDepthTuple& state_depth_pair, const SymbolPost& move, + std::deque& worklist); + + /** + * @brief Remove inner initial and final states. + * + * Remove all initial states for all segments but the first one and all final states for all segments but the + * last one. + */ + void remove_inner_initial_and_final_states(); +}; // Class Segmentation. + +/// A noodle is represented as a sequence of segments (a copy of the segment automata) created as if there was exactly +/// one ε-transition between each two consecutive segments. +using Noodle = std::vector>; +/// Segment with a counter of visited epsilons. +using SegmentWithEpsilonsCounter = std::pair, VisitedEpsilonsCounterVector>; +/// Noodles as segments enriched with EpsCntMap +using NoodleWithEpsilonsCounter = std::vector; + +/** + * @brief segs_one_initial_final + * + * segments_one_initial_final[init, final] is the pointer to automaton created from one of + * the segments such that init and final are one of the initial and final states of the segment + * and the created automaton takes this segment, sets initial={init}, final={final} + * and trims it; also segments_one_initial_final[unused_state, final] is used for the first + * segment (where we always want all initial states, only final state changes) and + * segments_one_initial_final[init, unused_state] is similarly for the last segment + * TODO: should we use unordered_map? then we need hash + */ +void segs_one_initial_final( + const std::vector& segments, bool include_empty, const State& unused_state, + std::map, std::shared_ptr>& out); + +/** + * @brief Create noodles from segment automaton @p aut. + * + * Segment automaton is a chain of finite automata (segments) connected via ε-transitions. + * A noodle is a vector of pointers to copy of the segments automata created as if there was exactly one ε-transition + * between each two consecutive segments. + * + * @param[in] automaton Segment automaton to noodlify. + * @param[in] epsilon Epsilon symbol to noodlify for. + * @param[in] include_empty Whether to also include empty noodles. + * @return A list of all (non-empty) noodles. + */ +std::vector noodlify(const SegCntnfa& aut, Symbol epsilon, bool include_empty = false); + +/** + * @brief Create noodles from segment automaton @p aut. + * + * Segment automaton is a chain of finite automata (segments) connected via ε-transitions. + * A noodle is a vector of pointers to copy of the segments automata created as if there was exactly one ε-transition + * between each two consecutive segments. + * + * @param[in] automaton Segment automaton to noodlify. + * @param[in] epsilons Epsilon symbols to noodlify for. + * @param[in] include_empty Whether to also include empty noodles. + * @return A list of all (non-empty) noodles. + */ +std::vector noodlify_mult_eps(const SegCntnfa& aut, const std::set& epsilons, bool include_empty = false); + +/** + * @brief Create noodles for left and right side of equation. + * + * Segment automaton is a chain of finite automata (segments) connected via ε-transitions. + * A noodle is a copy of the segment automaton with exactly one ε-transition between each two consecutive segments. + * + * Mata cannot work with equations, queries etc. Hence, we compute the noodles for the equation, but represent + * the equation in a way that libMata understands. The left side automata represent the left side of the equation + * and the right automaton represents the right side of the equation. To create noodles, we need a segment automaton + * representing the intersection. That can be achieved by computing a product of both sides. First, the left side + * has to be concatenated over an epsilon transitions into a single automaton to compute the intersection on, though. + * + * @param[in] lhs_automata Sequence of segment automata for left side of an equation to noodlify. + * @param[in] rhs_automaton Segment automaton for right side of an equation to noodlify. + * @param[in] include_empty Whether to also include empty noodles. + * @param[in] params Additional parameters for the noodlification: + * - "reduce": "false", "forward", "backward", "bidirectional"; Execute forward, backward or bidirectional simulation + * minimization before noodlification. + * @return A list of all (non-empty) noodles. + */ +std::vector noodlify_for_equation(const std::vector>& lhs_automata, + const Cntnfa& rhs_automaton, + bool include_empty = false, const ParameterMap& params = {{ "reduce", "false"}}); + +/** + * @brief Create noodles for left and right side of equation. + * + * Segment automaton is a chain of finite automata (segments) connected via ε-transitions. + * A noodle is a copy of the segment automaton with exactly one ε-transition between each two consecutive segments. + * + * Mata cannot work with equations, queries etc. Hence, we compute the noodles for the equation, but represent + * the equation in a way that libMata understands. The left side automata represent the left side of the equation + * and the right automaton represents the right side of the equation. To create noodles, we need a segment automaton + * representing the intersection. That can be achieved by computing a product of both sides. First, the left side + * has to be concatenated over an epsilon transitions into a single automaton to compute the intersection on, though. + * + * @param[in] lhs_automata Sequence of pointers to segment automata for left side of an equation to noodlify. + * @param[in] rhs_automaton Segment automaton for right side of an equation to noodlify. + * @param[in] include_empty Whether to also include empty noodles. + * @param[in] params Additional parameters for the noodlification: + * - "reduce": "false", "forward", "backward", "bidirectional"; Execute forward, backward or bidirectional simulation + * minimization before noodlification. + * @return A list of all (non-empty) noodles. + */ +std::vector noodlify_for_equation( + const std::vector& lhs_automata, const Cntnfa& rhs_automaton, bool include_empty = false, + const ParameterMap& params = {{ "reduce", "false"}}); + +/** + * @brief Create noodles for left and right side of equation (both sides are given as a sequence of automata). + * + * @param[in] lhs_automata Sequence of pointers to segment automata for left side of an equation to noodlify. + * @param[in] rhs_automaton Sequence of pointers to segment automata for right side of an equation to noodlify. + * @param[in] include_empty Whether to also include empty noodles. + * @param[in] params Additional parameters for the noodlification: + * - "reduce": "false", "forward", "backward", "bidirectional"; Execute forward, backward or bidirectional simulation + * minimization before noodlification. + * @return A list of all (non-empty) noodles together with the positions reached from the beginning of left/right side. + */ +std::vector noodlify_for_equation( + const std::vector>& lhs_automata, + const std::vector>& rhs_automata, + bool include_empty = false, const ParameterMap& params = {{ "reduce", "false"}}); + +/** + * @brief Process epsilon map to a sequence of values (sorted according to key desc) + * + * @param eps_cnt Epsilon count + * @return Vector of keys (count of epsilons) + */ +VisitedEpsilonsCounterVector process_eps_map(const VisitedEpsilonsCounterMap& eps_cnt); + +} // namespace SegCntnfa. + +} // namespace mata::strings. diff --git a/include/mata/cntnfa/types.hh b/include/mata/cntnfa/types.hh new file mode 100644 index 000000000..e8f21c551 --- /dev/null +++ b/include/mata/cntnfa/types.hh @@ -0,0 +1,75 @@ +// TODO: Insert file header. + +#pragma once + +#include + +#include "mata/alphabet.hh" +#include "mata/cntnfa/registers.hh" + +// Use this for undefined annotations +// TODO: Use std::optional instead of this? +#define MAX_SIZE_T (std::numeric_limits::max()) +#define UNDEFINED_ANNOTATIONS MAX_SIZE_T +#define UNDEFINED_REGISTER MAX_SIZE_T + +namespace mata::cntnfa { + +extern const std::string TYPE_CNTNFA; + +using State = unsigned long; +using StateSet = mata::utils::OrdVector; + +using Counter = Register; +using CounterSet = RegisterSet; +using CounterValue = RegisterValue; +using CounterName = RegisterName; + +struct Run { + Word word{}; ///< A finite-length word. + std::vector path{}; ///< A finite-length path through automaton. +}; + +// Configuration of the counter automaton. +struct Configuration { + State state; ///< The current state of the automaton. + RegisterSet registers; ///< The current values of the registers. + + Configuration() : state(), registers() {} + Configuration(State state, RegisterSet registers) + : state(state), registers(registers) {} + + bool operator==(const Configuration& other) const { + return state == other.state && registers == other.registers; + } +}; + +using StateRenaming = std::unordered_map; + +/** + * @brief Map of additional parameter name and value pairs. + * + * Used by certain functions for specifying some additional parameters in the following format: + * ```cpp + * ParameterMap { + * { "algorithm", "classical" }, + * { "minimize", "true" } + * } + * ``` + */ +using ParameterMap = std::unordered_map; + +struct Limits { +public: + static const State min_state = std::numeric_limits::min(); + static const State max_state = std::numeric_limits::max(); + static const Symbol min_symbol = std::numeric_limits::min(); + static const Symbol max_symbol = std::numeric_limits::max(); +}; + +struct Cntnfa; ///< A non-deterministic finite automaton with counters. + +/// An epsilon symbol which is now defined as the maximal value of data type used for symbols. +constexpr Symbol EPSILON = Limits::max_symbol; + +} // namespace mata::cntnfa. diff --git a/include/mata/nfa/algorithms.hh b/include/mata/nfa/algorithms.hh index f3b993ba0..c067eddab 100644 --- a/include/mata/nfa/algorithms.hh +++ b/include/mata/nfa/algorithms.hh @@ -4,7 +4,7 @@ #ifndef MATA_NFA_INTERNALS_HH_ #define MATA_NFA_INTERNALS_HH_ -#include "nfa.hh" +#include "mata/nfa/nfa.hh" #include "mata/simlib/util/binary_relation.hh" /** diff --git a/include/mata/nfa/builder.hh b/include/mata/nfa/builder.hh index 27f4abe34..0eb370c8d 100644 --- a/include/mata/nfa/builder.hh +++ b/include/mata/nfa/builder.hh @@ -3,7 +3,7 @@ #ifndef LIBMATA_BUILDER_HH #define LIBMATA_BUILDER_HH -#include "nfa.hh" +#include "mata/nfa/nfa.hh" #include diff --git a/include/mata/nfa/nfa.hh b/include/mata/nfa/nfa.hh index 80908f8f6..37866e2ed 100644 --- a/include/mata/nfa/nfa.hh +++ b/include/mata/nfa/nfa.hh @@ -28,8 +28,8 @@ #include "mata/parser/inter-aut.hh" #include "mata/utils/synchronized-iterator.hh" #include "mata/utils/sparse-set.hh" -#include "types.hh" -#include "delta.hh" +#include "mata/nfa/types.hh" +#include "mata/nfa/delta.hh" /** * @brief Nondeterministic Finite Automata including structures, transitions and algorithms. diff --git a/include/mata/nfa/plumbing.hh b/include/mata/nfa/plumbing.hh index 94f39ee46..9b707b473 100644 --- a/include/mata/nfa/plumbing.hh +++ b/include/mata/nfa/plumbing.hh @@ -6,8 +6,8 @@ #include "mata/nfa/algorithms.hh" #include "mata/nfa/types.hh" -#include "nfa.hh" -#include "builder.hh" +#include "mata/nfa/nfa.hh" +#include "mata/nfa/builder.hh" using namespace mata::nfa::builder; diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 0bfc68a4b..90f0c0258 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -23,7 +23,6 @@ add_library(libmata STATIC nfa/delta.cc nfa/operations.cc nfa/builder.cc - nft/nft.cc nft/inclusion.cc nft/universal.cc @@ -34,6 +33,17 @@ add_library(libmata STATIC nft/operations.cc nft/builder.cc nft/strings.cc + cntnfa/cntnfa.cc + cntnfa/inclusion.cc + cntnfa/universal.cc + cntnfa/complement.cc + cntnfa/product.cc + cntnfa/concatenation.cc + cntnfa/delta.cc + cntnfa/operations.cc + cntnfa/builder.cc + cntnfa/annotations.cc + cntnfa/registers.cc ) # libmata needs at least c++20 diff --git a/src/cntnfa/annotations.cc b/src/cntnfa/annotations.cc new file mode 100644 index 000000000..af72a29ca --- /dev/null +++ b/src/cntnfa/annotations.cc @@ -0,0 +1,221 @@ +// TODO: Insert header file. + +#include "mata/cntnfa/annotations.hh" + +namespace mata::cntnfa { + +/* TransitionAnnotation */ + +/* CounterAssign */ +void CounterAssign::update(CounterSet& counters) const { + if (register_id >= counters.size()) { + throw std::runtime_error("CounterAssign: Invalid counter ID."); + } + + Register& counter = counters[register_id]; + + if (value > 0) { + counter.set(value); + } else { + counter.set(0); + } +} + +bool CounterAssign::guard(const CounterSet& counters) const { + (void)counters; + return true; +} + +bool CounterAssign::apply(CounterSet& counters) const { + update(counters); + return true; +} + +AnnotationType CounterAssign::get_type() const { + return AnnotationType::CounterAssign; +} + +/* CounterIncrement */ +void CounterIncrement::update(CounterSet& counters) const { + if (register_id >= counters.size()) { + throw std::runtime_error("CounterIncrement: Invalid counter ID."); + } + + Register& counter = counters[register_id]; + + if (value > 0) { + counter.increment(value); + } else if (value < 0) { + counter.decrement(-value); + } +} + +bool CounterIncrement::guard(const CounterSet& counters) const { + (void)counters; + return true; +} + +bool CounterIncrement::apply(CounterSet& counters) const { + update(counters); + return true; +} + +AnnotationType CounterIncrement::get_type() const { + return AnnotationType::CounterIncrement; +} + +/* CounterEqual */ +void CounterEqual::update(CounterSet& counters) const { + (void)counters; + return; +} + +bool CounterEqual::guard(const CounterSet& counters) const { + if (register_id >= counters.size()) { + throw std::runtime_error("CounterEqual: Invalid counter ID."); + } + return counters[register_id].value == value; +} + +bool CounterEqual::apply(CounterSet& counters) const { + return guard(counters); +} + +AnnotationType CounterEqual::get_type() const { + return AnnotationType::CounterEqual; +} + +/* CounterNotEqual */ +void CounterNotEqual::update(CounterSet& counters) const { + (void)counters; + return; +} + +bool CounterNotEqual::guard(const CounterSet& counters) const { + if (register_id >= counters.size()) { + throw std::runtime_error("CounterNotEqual: Invalid counter ID."); + } + return counters[register_id].value != value; +} + +bool CounterNotEqual::apply(CounterSet& counters) const { + return guard(counters); +} + +AnnotationType CounterNotEqual::get_type() const { + return AnnotationType::CounterNotEqual; +} + +/* CounterGreater */ +void CounterGreater::update(CounterSet& counters) const { + (void)counters; + return; +} + +bool CounterGreater::guard(const CounterSet& counters) const { + if (register_id >= counters.size()) { + throw std::runtime_error("CounterGreater: Invalid counter ID."); + } + return counters[register_id].value > value; +} + +bool CounterGreater::apply(CounterSet& counters) const { + return guard(counters); +} + +AnnotationType CounterGreater::get_type() const { + return AnnotationType::CounterGreater; +} + +/* CounterLess */ +void CounterLess::update(CounterSet& counters) const { + (void)counters; + return; +} + +bool CounterLess::guard(const CounterSet& counters) const { + if (register_id >= counters.size()) { + throw std::runtime_error("CounterLess: Invalid counter ID."); + } + return counters[register_id].value < value; +} + +bool CounterLess::apply(CounterSet& counters) const { + return guard(counters); +} + +AnnotationType CounterLess::get_type() const { + return AnnotationType::CounterLess; +} + +/* CounterGreaterEqual */ +void CounterGreaterEqual::update(CounterSet& counters) const { + (void)counters; + return; +} + +bool CounterGreaterEqual::guard(const CounterSet& counters) const { + if (register_id >= counters.size()) { + throw std::runtime_error("CounterGreaterEqual: Invalid counter ID."); + } + return counters[register_id].value >= value; +} + +bool CounterGreaterEqual::apply(CounterSet& counters) const { + return guard(counters); +} + +AnnotationType CounterGreaterEqual::get_type() const { + return AnnotationType::CounterGreaterEqual; +} + +/* CounterLessEqual */ +void CounterLessEqual::update(CounterSet& counters) const { + (void)counters; + return; +} + +bool CounterLessEqual::guard(const CounterSet& counters) const { + if (register_id >= counters.size()) { + throw std::runtime_error("CounterLessEqual: Invalid counter ID."); + } + return counters[register_id].value <= value; +} + +bool CounterLessEqual::apply(CounterSet& counters) const { + return guard(counters); +} + +AnnotationType CounterLessEqual::get_type() const { + return AnnotationType::CounterLessEqual; +} + +/* AnnotationCollection */ + +void AnnotationCollection::allocate(const size_t size) { + assert(size >= annotations.size()); + annotations.resize(size); +} + +size_t AnnotationCollection::size() const { + return annotations.size(); +} + +void AnnotationCollection::clear() { + annotations.clear(); +} + +void AnnotationCollection::insert(std::shared_ptr annotation, size_t index) { + if (index >= annotations.size()) { + this->allocate(index + 1); + } + annotations[index].push_back(annotation); +} + +size_t AnnotationCollection::insert(std::shared_ptr annotation) { + annotations.emplace_back(); + annotations.back().push_back(annotation); + return annotations.size() - 1; +} + +} // namespace mata::cntnfa. diff --git a/src/cntnfa/builder.cc b/src/cntnfa/builder.cc new file mode 100644 index 000000000..fb93bd197 --- /dev/null +++ b/src/cntnfa/builder.cc @@ -0,0 +1,399 @@ +// TODO: Insert header file. + +#include "mata/cntnfa/builder.hh" +#include "mata/cntnfa/annotations.hh" +#include "mata/cntnfa/types.hh" + +#include + +using namespace mata::cntnfa; +using mata::cntnfa::Cntnfa; +using mata::Symbol; + +Cntnfa builder::construct_counter_nfa(const mata::parser::ParsedSection& parsec, Alphabet* alphabet, NameStateMap* state_map) +{ + Cntnfa aut; + assert(alphabet != nullptr); + + // A lambda for translating state names to identifiers + // TODO: Currently supports only explicit CNTNFA + if (parsec.type != "CNTNFA-explicit") { + throw std::runtime_error(std::string(__FUNCTION__) + ": expecting type \"CNTNFA-explicit\""); + } + + bool remove_state_map = false; + if (state_map == nullptr) { + state_map = new NameStateMap(); + remove_state_map = true; + } + + // A lambda for translating state names to identifiers + auto get_state = [&aut, &state_map](const std::string& name) -> State { + auto it = state_map->find(name); + if (it == state_map->end()) { + State s; + if (name.size() >= 2 && name[0] == 'q' && std::isdigit(name[1])) { + s = aut.add_state(static_cast(std::stoi(name.substr(1)))); + } else { + s = aut.add_state(); + } + (*state_map)[name] = s; + return s; + } + return it->second; + }; + + // A lambda for cleanup + auto clean_up = [&]() { + if (remove_state_map) delete state_map; + }; + + // Parse the initial states + if (parsec.haskey("Initial")) { + for (const auto& name : parsec["Initial"]) + aut.initial.insert(get_state(name)); + } + + // Parse the final states + if (parsec.haskey("Final")) { + for (const auto& name : parsec["Final"]) + aut.final.insert(get_state(name)); + } + + // Parse the registers + if (parsec.haskey("Registers")) { + for (const auto& name : parsec["Registers"]) { + aut.counter_set.add(name); + } + } + + // Parse the transitions + for (const auto& line : parsec.body) { + if (line.size() < 3) { + clean_up(); + throw std::runtime_error("Invalid transition: too few tokens"); + } + + State source = get_state(line[0]); + Symbol symbol = alphabet->translate_symb(line[1]); + State target = get_state(line.back()); + + // Allocate annotation group + // size_t annotations_id = aut.annotation_collection.size(); + // aut.annotation_collection.allocate(annotation_id + 1); + + // Default: no annotations + size_t annotations_id = UNDEFINED_ANNOTATIONS; + + // Parse all annotation groups between symbol and target + for (size_t i = 2; i + 1 < line.size(); ++i) { + if (line[i] == "(") { + std::vector group; + ++i; + while (i < line.size() && line[i] != ")") { + group.push_back(line[i]); + ++i; + } + + if (group.size() != 3) { + clean_up(); + throw std::runtime_error("Annotation must have 3 parts: (type name value)"); + } + + const std::string& type = group[0]; + const std::string& name = group[1]; + int value = std::stoi(group[2]); + + if (!aut.counter_set.has(name)) { + clean_up(); + throw std::runtime_error("Unknown counter in annotation: " + name); + } + + if (annotations_id == UNDEFINED_ANNOTATIONS) { + annotations_id = aut.create_annotation_set(); + } + + size_t counter_id = aut.counter_set.get_index(name); + + if (type == ":=") { + aut.annotation_collection.insert( + std::make_shared(counter_id, value), annotations_id); + } else if (type == "+") { + aut.annotation_collection.insert( + std::make_shared(counter_id, value), annotations_id); + } else if (type == "=") { + aut.annotation_collection.insert( + std::make_shared(counter_id, value), annotations_id); + } else if (type == "!=") { + aut.annotation_collection.insert( + std::make_shared(counter_id, value), annotations_id); + } else if (type == ">") { + aut.annotation_collection.insert( + std::make_shared(counter_id, value), annotations_id); + } else if (type == "<") { + aut.annotation_collection.insert( + std::make_shared(counter_id, value), annotations_id); + } else if (type == ">=") { + aut.annotation_collection.insert( + std::make_shared(counter_id, value), annotations_id); + } else if (type == "<=") { + aut.annotation_collection.insert( + std::make_shared(counter_id, value), annotations_id); + } else { + clean_up(); + throw std::runtime_error("Unsupported annotation type: " + type); + } + } + } + + // Create transition with annotation ID + aut.delta.add(source, symbol, AnnotationState{target, annotations_id}); + } + + clean_up(); + return aut; +} // construct_counter_nfa(). + +Cntnfa builder::construct(const mata::parser::ParsedSection& parsec, mata::Alphabet* alphabet, NameStateMap* state_map) { + Cntnfa aut; + assert(nullptr != alphabet); + + if (parsec.type != TYPE_CNTNFA) { + throw std::runtime_error(std::string(__FUNCTION__) + ": expecting type \"" + + TYPE_CNTNFA + "\""); + } + + bool remove_state_map = false; + if (nullptr == state_map) { + state_map = new NameStateMap(); + remove_state_map = true; + } + + // a lambda for translating state names to identifiers + auto get_state_name = [&state_map, &aut](const std::string& str) { + if (!state_map->count(str)) { + State state = aut.add_state(); + state_map->insert({str, state}); + return state; + } else { + return (*state_map)[str]; + } + }; + + // a lambda for cleanup + auto clean_up = [&]() { + if (remove_state_map) { delete state_map; } + }; + + + auto it = parsec.dict.find("Initial"); + if (parsec.dict.end() != it) + { + for (const auto& str : it->second) + { + State state = get_state_name(str); + aut.initial.insert(state); + } + } + + + it = parsec.dict.find("Final"); + if (parsec.dict.end() != it) + { + for (const auto& str : it->second) + { + State state = get_state_name(str); + aut.final.insert(state); + } + } + + for (const auto& body_line : parsec.body) + { + if (body_line.size() != 3) + { + // clean up + clean_up(); + + if (body_line.size() == 2) + { + throw std::runtime_error("Epsilon transitions not supported: " + + std::to_string(body_line)); + } + else + { + throw std::runtime_error("Invalid transition: " + + std::to_string(body_line)); + } + } + + State src_state = get_state_name(body_line[0]); + Symbol symbol = alphabet->translate_symb(body_line[1]); + Target tgt_state = get_state_name(body_line[2]); + + aut.delta.add(src_state, symbol, tgt_state); + } + + // do the dishes and take out garbage + clean_up(); + + return aut; +} // construct(). + +Cntnfa builder::construct(const mata::IntermediateAut& inter_aut, mata::Alphabet* alphabet, NameStateMap* state_map) { + Cntnfa aut; + assert(nullptr != alphabet); + + if (!inter_aut.is_nfa()) { + throw std::runtime_error(std::string(__FUNCTION__) + ": expecting type \"" + + TYPE_CNTNFA + "\""); + } + + NameStateMap tmp_state_map; + if (nullptr == state_map) { + state_map = &tmp_state_map; + } + + // a lambda for translating state names to identifiers + auto get_state_name = [&state_map, &aut](const std::string& str) { + if (!state_map->count(str)) { + State state = aut.add_state(); + state_map->insert({str, state}); + return state; + } else { + return (*state_map)[str]; + } + }; + + for (const auto& str : inter_aut.initial_formula.collect_node_names()) + { + State state = get_state_name(str); + aut.initial.insert(state); + } + + for (const auto& trans : inter_aut.transitions) + { + if (trans.second.children.size() != 2) + { + if (trans.second.children.size() == 1) + { + throw std::runtime_error("Epsilon transitions not supported"); + } + else + { + throw std::runtime_error("Invalid transition"); + } + } + + State src_state = get_state_name(trans.first.name); + Symbol symbol = alphabet->translate_symb(trans.second.children[0].node.name); + Target tgt_state = get_state_name(trans.second.children[1].node.name); + + aut.delta.add(src_state, symbol, tgt_state); + } + + std::unordered_set final_formula_nodes; + if (!(inter_aut.final_formula.node.is_constant())) { + // we do not want to parse true/false (constant) as a state so we do not collect it + final_formula_nodes = inter_aut.final_formula.collect_node_names(); + } + // for constant true, we will pretend that final nodes are negated with empty final_formula_nodes + bool final_nodes_are_negated = (inter_aut.final_formula.node.is_true() || inter_aut.are_final_states_conjunction_of_negation()); + + if (final_nodes_are_negated) { + // we add all states NOT in final_formula_nodes to final states + for (const auto &state_name_and_id : *state_map) { + if (!final_formula_nodes.count(state_name_and_id.first)) { + aut.final.insert(state_name_and_id.second); + } + } + } else { + // we add all states in final_formula_nodes to final states + for (const auto& str : final_formula_nodes) + { + State state = get_state_name(str); + aut.final.insert(state); + } + } + + return aut; +} // construct(). + +void builder::construct( + mata::cntnfa::Cntnfa *result, + const mata::IntermediateAut &inter_aut, + mata::Alphabet *alphabet, + mata::cntnfa::builder::NameStateMap *state_map +) { + *result = construct(inter_aut, alphabet, state_map); +} + +Cntnfa builder::create_single_word_nfa(const std::vector& word) { + const size_t word_size{ word.size() }; + Cntnfa nfa{ word_size + 1, { 0 }, { word_size } }; + + for (State state{ 0 }; state < word_size; ++state) { + nfa.delta.add(state, word[state], Target(state + 1)); + } + return nfa; +} + +Cntnfa builder::create_single_word_nfa(const std::vector& word, mata::Alphabet *alphabet) { + if (!alphabet) { + alphabet = new OnTheFlyAlphabet{ word }; + } + const size_t word_size{ word.size() }; + Cntnfa nfa{ word_size + 1, { 0 }, { word_size }, {}, {}, alphabet }; + + for (State state{ 0 }; state < word_size; ++state) { + nfa.delta.add(state, alphabet->translate_symb(word[state]), Target(state + 1)); + } + return nfa; +} + +Cntnfa builder::create_empty_string_nfa() { + return Cntnfa{ 1, StateSet{ 0 }, StateSet{ 0 } }; +} + +Cntnfa builder::create_sigma_star_nfa(mata::Alphabet* alphabet) { + Cntnfa nfa{ 1, StateSet{ 0 }, StateSet{ 0 }, {}, {}, alphabet }; + for (const mata::Symbol& symbol : alphabet->get_alphabet_symbols()) { + nfa.delta.add(0, symbol, Target(0)); + } + return nfa; +} + +Cntnfa builder::parse_from_mata(std::istream& nfa_stream) { + const std::string nfa_str = "NFA"; + parser::Parsed parsed{ parser::parse_mf(nfa_stream) }; + if (parsed.size() != 1) { + throw std::runtime_error("The number of sections in the input file is '" + std::to_string(parsed.size()) + + "'. Required is '1'.\n"); + } + const std::string automaton_type{ parsed[0].type }; + if (automaton_type.compare(0, nfa_str.length(), nfa_str) != 0) { + throw std::runtime_error("The type of input automaton is '" + automaton_type + "'. Required is 'NFA'\n"); + } + IntAlphabet alphabet; + return construct(IntermediateAut::parse_from_mf(parsed)[0], &alphabet); +} + +Cntnfa builder::parse_from_mata(const std::filesystem::path& nfa_file) { + std::ifstream file_stream{ nfa_file }; + if (!file_stream) { + throw std::runtime_error("Could not open file \'" + nfa_file.string() + "'\n"); + } + + Cntnfa nfa; + try { + nfa = parse_from_mata(file_stream); + } catch (const std::exception& ex) { + file_stream.close(); + throw; + } + return nfa; +} + +Cntnfa builder::parse_from_mata(const std::string& nfa_in_mata) { + std::istringstream nfa_stream(nfa_in_mata); + return parse_from_mata(nfa_stream); +} diff --git a/src/cntnfa/cntnfa.cc b/src/cntnfa/cntnfa.cc new file mode 100644 index 000000000..622830208 --- /dev/null +++ b/src/cntnfa/cntnfa.cc @@ -0,0 +1,764 @@ +/* cntnfa.cc -- operations for NFA + */ + +#include +#include +#include + +// MATA headers +#include "mata/cntnfa/annotations.hh" +#include "mata/utils/ord-vector.hh" +#include "mata/utils/sparse-set.hh" +#include "mata/cntnfa/cntnfa.hh" +#include + +using namespace mata::utils; +using namespace mata::cntnfa; +using mata::Symbol; +using mata::Word; +using mata::BoolVector; + +using StateBoolArray = std::vector; ///< Bool array for states in the automaton. + +const std::string mata::cntnfa::TYPE_CNTNFA = "CNTNFA"; + +const State Limits::min_state; +const State Limits::max_state; +const Symbol Limits::min_symbol; +const Symbol Limits::max_symbol; + +namespace { + /** + * Compute reachability of states considering only specified states. + * + * @param[in] nfa NFA to compute reachability for. + * @param[in] states_to_consider State to consider as potentially reachable. If @c std::nullopt is used, all states + * are considered as potentially reachable. + * @return Bool array for reachable states (from initial states): true for reachable, false for unreachable states. + */ + StateBoolArray reachable_states(const Cntnfa& nfa, + const std::optional& states_to_consider = std::nullopt) { + std::vector worklist{}; + StateBoolArray reachable(nfa.num_of_states(), false); + for (const State state: nfa.initial) { + if (!states_to_consider.has_value() || states_to_consider.value()[state]) { + worklist.push_back(state); + reachable.at(state) = true; + } + } + + State state; + while (!worklist.empty()) { + state = worklist.back(); + worklist.pop_back(); + for (const SymbolPost& move: nfa.delta[state]) { + for (const State target_state: move.targets) { + if (!reachable[target_state] && + (!states_to_consider.has_value() || states_to_consider.value()[target_state])) { + worklist.push_back(target_state); + reachable[target_state] = true; + } + } + } + } + return reachable; + } +} + +void Cntnfa::remove_epsilon(const Symbol epsilon) +{ + *this = mata::cntnfa::remove_epsilon(*this, epsilon); +} + +StateSet Cntnfa::get_reachable_states() const { + StateBoolArray reachable_bool_array{ reachable_states(*this) }; + + StateSet reachable_states{}; + const size_t num_of_states{ this->num_of_states() }; + for (State original_state{ 0 }; original_state < num_of_states; ++original_state) + { + if (reachable_bool_array[original_state]) + { + reachable_states.insert(original_state); + } + } + + return reachable_states; +} + +StateSet Cntnfa::get_terminating_states() const +{ + return revert(*this).get_reachable_states(); +} + +std::vector Cntnfa::distances_from_initial() const { + std::vector distances(num_of_states()+1, Limits::max_state); + BoolVector visited(num_of_states()+1, false); + std::deque que; + + for (State qi: initial) { + visited[qi] = true; + distances[qi] = 0; + que.push_back(qi); + } + + while (!que.empty()) { + State src = que.front(); + que.pop_front(); + for (Move move : delta[src].moves()) { + if (!visited[move.target]) { + visited[move.target] = true; + distances[move.target] = distances[src] +1; + que.push_back(move.target); + } + } + } + + return distances; +} + +std::vector Cntnfa::distances_to_final() const { + return revert(*this).distances_from_initial(); +} + +Run Cntnfa::get_shortest_accepting_run_from_state(State q, const std::vector& distances_to_final) const { + Run result{{}, {q}}; + while (!final[q]) { + for (Move move : delta[q].moves()) { + if (distances_to_final[move.target] < distances_to_final[q]) { + result.word.push_back(move.symbol); + result.path.push_back(move.target); + q = move.target; + break; + } + } + } + return result; +} + +Cntnfa& Cntnfa::trim(StateRenaming* state_renaming) { +#ifdef _STATIC_STRUCTURES_ + BoolVector useful_states{ useful_states() }; + useful_states.clear(); + useful_states = useful_states(); +#else + BoolVector useful_states{ get_useful_states() }; +#endif + const size_t useful_states_size{ useful_states.size() }; + // Note: Changed std::vector to std::vector. + std::vector renaming(useful_states_size); + for(State new_state{ 0 }, orig_state{ 0 }; orig_state < useful_states_size; ++orig_state) { + if (useful_states[orig_state]) { + renaming[orig_state] = new_state; + ++new_state; + } + } + + delta.defragment(useful_states, renaming); + + auto is_state_useful = [&](State q){return q < useful_states.size() && useful_states[q];}; + initial.filter(is_state_useful); + final.filter(is_state_useful); + auto rename_state = [&](State q){return renaming[q];}; + initial.rename(rename_state); + final.rename(rename_state); + initial.truncate(); + final.truncate(); + if (state_renaming != nullptr) { + state_renaming->clear(); + state_renaming->reserve(useful_states_size); + for (State q{ 0 }; q < useful_states_size; ++q) { + if (useful_states[q]) { + (*state_renaming)[q] = renaming[q]; + } + } + } + return *this; +} + +namespace { + // A structure to store metadata related to each state/node during the computation + // of useful states. It contains Tarjan's metadata and the state of the + // iteration through the successors. + struct TarjanNodeData { + StatePost::Moves::const_iterator current_move{}; + StatePost::Moves::const_iterator end_move{}; + // index of a node (corresponds to the time of discovery) + unsigned long index{ 0 }; + // index of a lower node in the same SCC + unsigned long lowlink{ 0 }; + // was the node already initialized (=the initial phase of the Tarjan's recursive call was executed) + bool initilized{ false }; + // is node on Tarjan's stack? + bool on_stack{ false }; + + TarjanNodeData() = default; + + TarjanNodeData(State q, const Delta& delta, unsigned long index) + : index(index), lowlink(index), initilized(true), on_stack(true) { + const StatePost::Moves moves{ delta[q].moves() }; + current_move = moves.begin(); + end_move = moves.end(); + }; + }; +}; + +/** + * @brief This function employs non-recursive version of Tarjan's algorithm for finding SCCs + * (see https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm, in particular strongconnect(v)) + * The method saturates a bool vector @p reached_and_reaching in a way that reached_and_reaching[i] = true iff + * the state i is useful at the end. To break the recursiveness, we use @p program_stack simulating + * the program stack during the recursive calls of strongconnect(v) (see the wiki). + * + * Node data + * - lowlink, index, on_stack (the same as from strongconnect(v)) + * - initialized (flag denoting whether the node started to be processing in strongconnect) + * - bunch of iterators allowing to iterate over successors (and store the state of the iteration) + * + * Program stack @p program_stack + * - contains nodes + * - node on the top is being currently processed + * - node is removed after it has been completely processed (after the end of strongconnect) + * + * Simulation of strongconnect( @p act_state = v ) + * - if @p act_state is not initialized yet (corresponds to the initial phase of strongconnect), initialize + * - if @p act_state has already been initialized (i.e., processing of @p act_state was resumed by a + * recursive call, which already finished and we continue in processing of @p act_state ), we set + * @p act_state lowlink to min of current lowlink and the current successor @p act_succ of @p act_state. + * @p act_succ corresponds to w in strongconnect(v). In particular, in strongconnect(v) we called + * strongconnect(w) and now we continue after the return. + * - Then, we continue iterating over successors @p next_state of @p act_state: + * * if @p next_state is not initialized (corresponds to the first if in strongconnect(v)), we simulate + * the recursive call of strongconnect( @p next_state ): we put @p next_state on @p program_stack and + * jump to the processing of a new node from @p program_stack (we do not remove @p act_state from program + * stack yet). + * * otherwise update the lowlink + * - The rest corresponds to the last part of strongconnect(v) with a difference that if a node in the closed + * SCC if useful, we declare all nodes in the SCC useful and moreover we propagate usefulness also the states + * in @p tarjan_stack as it contains states that can reach this closed SCC. + * + */ +void Cntnfa::tarjan_scc_discover(const TarjanDiscoverCallback& callback) const { + std::vector node_info(this->num_of_states()); + std::vector program_stack; + std::vector tarjan_stack; + unsigned long index_cnt = 0; + + for(const State& q0 : initial) { + program_stack.push_back(q0); + } + + while(!program_stack.empty()) { + State act_state = program_stack.back(); + TarjanNodeData& act_state_data = node_info[act_state]; + + // if a node is initialized and is not on stack --> skip it; this state was + // already processed (=this state is initial and was reachable from another initial). + if(act_state_data.initilized && !act_state_data.on_stack) { + program_stack.pop_back(); + continue; + } + + // node has not been initialized yet --> corresponds to the first call of strongconnect(act_state) + if(!act_state_data.initilized) { + // initialize node + act_state_data = TarjanNodeData(act_state, this->delta, index_cnt++); + tarjan_stack.push_back(act_state); + + if(callback.state_discover && callback.state_discover(act_state)) { + return; + } + } else { // return from the recursive call + State act_succ = act_state_data.current_move->target; + act_state_data.lowlink = std::min(act_state_data.lowlink, node_info[act_succ].lowlink); + // act_succ is the state that cased the recursive call. Move to another successor. + ++act_state_data.current_move; + } + + // iterate through outgoing edges + State next_state; + // rec_call simulates call of the strongconnect. Since c++ cannot do continue over + // multiple loops, we use rec_call to jump to the main loop + bool rec_call = false; + for(; act_state_data.current_move != act_state_data.end_move; ++act_state_data.current_move) { + next_state = act_state_data.current_move->target; + if(callback.succ_state_discover) { + callback.succ_state_discover(act_state, next_state); + } + if(!node_info[next_state].initilized) { // recursive call + program_stack.push_back(next_state); + rec_call = true; + break; + } else if(node_info[next_state].on_stack) { + act_state_data.lowlink = std::min(act_state_data.lowlink, node_info[next_state].index); + } + } + if(rec_call) continue; + + // check if we have the root of a SCC + if(act_state_data.lowlink == act_state_data.index) { + State st; + std::vector scc; + do { + st = tarjan_stack.back(); + tarjan_stack.pop_back(); + node_info[st].on_stack = false; + + if(callback.scc_state_discover) { + callback.scc_state_discover(st); + } + scc.push_back(st); + } while(st != act_state); + if(callback.scc_discover && callback.scc_discover(scc, tarjan_stack)) { + return; + } + } + // all successors have been processed, we can remove act_state from the program stack + program_stack.pop_back(); + } +} + +BoolVector Cntnfa::get_useful_states() const { + BoolVector useful(this->num_of_states(), false); + bool final_scc = false; + + TarjanDiscoverCallback callback {}; + callback.state_discover = [&](State state) -> bool { + if(this->final.contains(state)) { + useful[state] = true; + } + return false; + }; + callback.scc_discover = [&](const std::vector& scc, const std::vector& tarjan_stack) -> bool { + if(final_scc) { + // Propagate usefulness to the closed SCC. + for(const State& st: scc) { useful[st] = true; } + // Propagate usefulness to predecessors in @p tarjan_stack. + for (auto state_it{ tarjan_stack.rbegin() }, state_it_end{ tarjan_stack.rend() }; + state_it != state_it_end; ++state_it) { + if (useful[*state_it]) { break; } + useful[*state_it] = true; + } + } + final_scc = false; + return false; + }; + callback.scc_state_discover = [&](State state) { + if(useful[state]) { + final_scc = true; + } + }; + callback.succ_state_discover = [&](State act_state, State next_state) { + if(useful[next_state]) { + useful[act_state] = true; + } + }; + + tarjan_scc_discover(callback); + return useful; +} + +bool Cntnfa::is_lang_empty_scc() const { + bool accepting_state = false; + + TarjanDiscoverCallback callback {}; + callback.state_discover = [&](State state) -> bool { + if(this->final.contains(state)) { + accepting_state = true; + return true; + } + return false; + }; + + tarjan_scc_discover(callback); + return !accepting_state; +} + +bool Cntnfa::is_acyclic() const { + bool acyclic = true; + + TarjanDiscoverCallback callback {}; + callback.scc_discover = [&](const std::vector& scc, const std::vector& tarjan_stack) -> bool { + (void)tarjan_stack; + if(scc.size() > 1) { + acyclic = false; + return true; + } else { // check for self-loops + State st = scc[0]; + for(const auto& sp : this->delta[st]) { + if(sp.targets.find(st) != sp.targets.end()) { + acyclic = false; + return true; + } + } + } + return false; + }; + + tarjan_scc_discover(callback); + return acyclic; +} + +bool Cntnfa::is_flat() const { + bool flat = true; + + mata::cntnfa::Cntnfa::TarjanDiscoverCallback callback {}; + callback.scc_discover = [&](const std::vector& scc, const std::vector& tarjan_stack) -> bool { + (void)tarjan_stack; + + for(const mata::cntnfa::State& st : scc) { + bool one_input_visited = false; + for (const mata::cntnfa::SymbolPost& sp : this->delta[st]) { + for (const mata::cntnfa::State& tgt : scc) { + if(sp.targets.contains(tgt)) { + if(one_input_visited) { + flat = false; + return true; + } + one_input_visited = true; + } + } + } + } + return false; + }; + + tarjan_scc_discover(callback); + return flat; +} + +std::string Cntnfa::print_to_dot() const { + std::stringstream output; + print_to_dot(output); + return output.str(); +} + +void Cntnfa::print_to_dot(std::ostream &output) const { + output << "digraph finiteAutomaton {" << std::endl + << "node [shape=circle];" << std::endl; + + for (State final_state: final) { + output << final_state << " [shape=doublecircle];" << std::endl; + } + + const size_t delta_size = delta.num_of_states(); + for (State source = 0; source != delta_size; ++source) { + for (const SymbolPost &move: delta[source]) { + output << source << " -> {"; + for (State target: move.targets) { + output << target << " "; + } + output << "} [label=" << move.symbol << "];" << std::endl; + } + } + + output << "node [shape=none, label=\"\"];" << std::endl; + for (State init_state: initial) { + output << "i" << init_state << " -> " << init_state << ";" << std::endl; + } + + output << "}" << std::endl; +} + +std::string Cntnfa::print_to_mata() const { + std::stringstream output; + print_to_mata(output); + return output.str(); +} + +void Cntnfa::print_to_mata(std::ostream &output) const { + output << "@NFA-explicit" << std::endl + << "%Alphabet-auto" << std::endl; + // TODO should be this, but we cannot parse %Alphabet-numbers yet + //<< "%Alphabet-numbers" << std::endl; + + if (!initial.empty()) { + output << "%Initial"; + for (State init_state: initial) { + output << " q" << init_state; + } + output << std::endl; + } + + if (!final.empty()) { + output << "%Final"; + for (State final_state: final) { + output << " q" << final_state; + } + output << std::endl; + } + + for (const Transition& trans: delta.transitions()) { + output << "q" << trans.source << " " << trans.symbol << " q" << trans.target << std::endl; + } +} + +Cntnfa Cntnfa::get_one_letter_aut(Symbol abstract_symbol) const { + Cntnfa digraph{num_of_states(), StateSet(initial), StateSet(final) }; + // Add directed transitions for digraph. + for (const Transition& transition: delta.transitions()) { + // Directly try to add the transition. Finding out whether the transition is already in the digraph + // only iterates through transition relation again. + digraph.delta.add(transition.source, abstract_symbol, transition.target); + } + return digraph; +} + +void Cntnfa::get_one_letter_aut(Cntnfa& result) const { + result = get_one_letter_aut(); +} + +StateSet Cntnfa::post(const StateSet& states, const Symbol& symbol) const { + StateSet res{}; + if (delta.empty()) { + return res; + } + + for (const State state: states) { + const StatePost& post{ delta[state] }; + // TODO: This does not handle epsilons. + const auto move_it{ post.find(symbol) }; + if (move_it != post.end()) { + res.insert(move_it->targets); + } + } + return res; +} + +void Cntnfa::unify_initial() { + if (initial.empty() || initial.size() == 1) { return; } + const State new_initial_state{add_state() }; + for (const State orig_initial_state: initial) { + const StatePost& moves{ delta.state_post(orig_initial_state) }; + for (const auto& transitions: moves) { + for (const Target target: transitions.targets) { + delta.add(new_initial_state, transitions.symbol, target); + } + } + if (final[orig_initial_state]) { final.insert(new_initial_state); } + } + initial.clear(); + initial.insert(new_initial_state); +} + +void Cntnfa::unify_final() { + if (final.empty() || final.size() == 1) { return; } + const Target new_final_state{ add_state() }; + for (const auto& orig_final_state: final) { + const auto transitions_to{ delta.get_transitions_to(orig_final_state) }; + for (const auto& transitions: transitions_to) { + delta.add(transitions.source, transitions.symbol, new_final_state); + } + if (initial[orig_final_state]) { initial.insert(new_final_state); } + } + final.clear(); + final.insert(new_final_state); +} + +Cntnfa& Cntnfa::operator=(Cntnfa&& other) noexcept { + if (this != &other) { + delta = std::move(other.delta); + initial = std::move(other.initial); + final = std::move(other.final); + alphabet = other.alphabet; + attributes = std::move(other.attributes); + other.alphabet = nullptr; + } + return *this; +} + +State Cntnfa::add_state() { + const size_t num_of_states{ this->num_of_states() }; + delta.allocate(num_of_states + 1); + return num_of_states; +} + +State Cntnfa::add_state(State state) { + if (state >= delta.num_of_states()) { + delta.allocate(state + 1); + } + return state; +} + +size_t Cntnfa::num_of_states() const { + return std::max({ + static_cast(initial.domain_size()), + static_cast(final.domain_size()), + static_cast(delta.num_of_states()) + }); +} + +size_t Cntnfa::create_annotation_set() { + const size_t num_of_annotation_sets{ this->num_of_annotation_sets() }; + annotation_collection.allocate(num_of_annotation_sets + 1); + return num_of_annotation_sets; +} + +size_t Cntnfa::add_annotation(size_t annotations_id, std::shared_ptr annotation) { + if (annotations_id >= annotation_collection.size()) { + annotation_collection.allocate(annotations_id + 1); + } + annotation_collection[annotations_id].insert(annotation); + return annotations_id; +} + +size_t Cntnfa::num_of_annotation_sets() const { + return annotation_collection.size(); +} + +size_t Cntnfa::num_of_counters() const { + return counter_set.size(); +} + +const OrdVector>& Cntnfa::get_annotation_set(size_t annotations_id) const { + if (annotations_id >= annotation_collection.size()) { + throw std::out_of_range("Invalid annotation ID."); + } + return annotation_collection[annotations_id]; +} + +void Cntnfa::clear() { + delta.clear(); + annotation_collection.clear(); + initial.clear(); + final.clear(); +} + +bool Cntnfa::is_identical(const Cntnfa& aut) const { + if (utils::OrdVector(initial) != utils::OrdVector(aut.initial)) { + return false; + } + if (utils::OrdVector(final) != utils::OrdVector(aut.final)) { + return false; + } + return delta == aut.delta; +} + +Cntnfa& Cntnfa::complement_deterministic(const OrdVector& symbols, std::optional sink_state) { + const State sink{ sink_state.value_or(num_of_states()) }; + if (initial.empty()) { // The automaton has no reachable states (accepting an empty language). + // Insert a single initial sink state. + initial.insert(sink); + } + make_complete(symbols, sink); + swap_final_nonfinal(); + return *this; +} + +Cntnfa& Cntnfa::unite_nondet_counter_nfa_with(const Cntnfa &aut) { + // Edge cases + if (this == &aut) { + return *this; + } + if (final.empty() || initial.empty()) { + *this = aut; + return *this; + } + if (aut.final.empty() || aut.initial.empty()) { + return *this; + } + + // Compute the new number of states, counters, and annotation sets + const size_t state_offset = this->num_of_states(); + const size_t counter_offset = this->num_of_counters(); + const size_t annotation_set_offset = this->num_of_annotation_sets(); + + const size_t total_states = aut.num_of_states() + state_offset; + const size_t total_counters = aut.num_of_counters() + counter_offset; + const size_t total_annotation_sets = aut.num_of_annotation_sets() + annotation_set_offset; + + // Reserve space for new states + this->delta.reserve(total_states); + // Allocate space for initial and final states from 'this' which might be missing in Delta + this->delta.allocate(state_offset); + // Allocate space for new counters + this->counter_set.allocate(total_counters); + // Allocate space for new annotation sets + this->annotation_collection.allocate(total_annotation_sets); + + // Add new counters from 'aut' to this automaton + for (size_t i = 0; i < aut.counter_set.size(); ++i) { + const auto& c = aut.counter_set.get(i); + this->counter_set.add_with_prefix("c", c.value); + } + + // Helper to remap annotation from lhs or rhs to result using new counter names + auto remap_annotation_counters = [&](const std::shared_ptr& ann, const CounterSet& from_set) + -> std::shared_ptr + { + std::string name = from_set.get_name(ann->get_register_id()); + size_t new_id = this->counter_set.get_index(name); + CounterValue val = ann->get_value(); + + // Handle each annotation type individually + if (ann->get_type() == AnnotationType::CounterAssign) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterIncrement) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterEqual) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterNotEqual) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterGreater) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterLess) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterGreaterEqual) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterLessEqual) return std::make_shared(new_id, val); + + throw std::runtime_error("Unknown annotation type"); + }; + + // Copy and remap annotation sets + for (size_t i = 0; i < aut.annotation_collection.size(); ++i) { + const auto& anns = aut.annotation_collection[i]; + size_t new_index = i + annotation_set_offset; + for (const auto& ann : anns) { + this->annotation_collection.insert(remap_annotation_counters(ann, aut.counter_set), new_index); + } + } + + // Copy transitions from 'aut', renumber states and annotations + this->delta.append_remapped(aut.delta, state_offset, annotation_set_offset); + + // Merge initial states + for (const State& s : aut.initial) { + this->initial.insert(s + state_offset); + } + + // Merge final states + for (const State& s : aut.final) { + this->final.insert(s + state_offset); + } + + return *this; +} + +Cntnfa& Cntnfa::unite_nondet_with(const mata::cntnfa::Cntnfa& aut) { + const size_t num_of_states{ this->num_of_states() }; + const size_t aut_num_of_states{ aut.num_of_states() }; + const size_t new_num_of_states{ num_of_states + aut_num_of_states }; + + if (this == &aut) { + return *this; + } + + if (final.empty() || initial.empty()) { *this = aut; return *this; } + if (aut.final.empty() || aut.initial.empty()) { return *this; } + + this->delta.reserve(new_num_of_states); + // Allocate space for initial and final states from 'this' which might be missing in Delta. + this->delta.allocate(num_of_states); + + auto renumber_states = [&](State st) { + return st + num_of_states; + }; + this->delta.append(aut.delta.renumber_targets(renumber_states)); + + // Set accepting states. + this->final.reserve(new_num_of_states); + for(const State& aut_fin: aut.final) { + this->final.insert(renumber_states(aut_fin)); + } + // Set initial states. + this->initial.reserve(new_num_of_states); + for(const State& aut_ini: aut.initial) { + this->initial.insert(renumber_states(aut_ini)); + } + + return *this; +} diff --git a/src/cntnfa/complement.cc b/src/cntnfa/complement.cc new file mode 100644 index 000000000..763e62fec --- /dev/null +++ b/src/cntnfa/complement.cc @@ -0,0 +1,50 @@ +/* cntnfa-complement.cc -- NFA complement + */ + +// MATA headers +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/algorithms.hh" + +using namespace mata::cntnfa; +using namespace mata::utils; + +Cntnfa mata::cntnfa::algorithms::complement_classical(const Cntnfa& aut, const OrdVector& symbols) { + return determinize(aut) + .trim() + .complement_deterministic(symbols); +} + +Cntnfa algorithms::complement_brzozowski(const Cntnfa& aut, const OrdVector& symbols) { + Cntnfa result{ minimize_brzozowski(aut) }; // Brzozowski minimization makes it deterministic. + if (result.final.empty() && !result.initial.empty()) { + assert(result.initial.size() == 1); + // If the DFA does not accept anything, then there is only one (initial) state which can be the sink state (so + // we do not create an unnecessary new sink state). + return result.complement_deterministic(symbols, *result.initial.begin()); + } + return result.complement_deterministic(symbols); +} + +Cntnfa mata::cntnfa::complement(const Cntnfa& aut, const Alphabet& alphabet, const ParameterMap& params) { + return mata::cntnfa::complement(aut, alphabet.get_alphabet_symbols(), params); +} + +Cntnfa mata::cntnfa::complement(const Cntnfa& aut, const mata::utils::OrdVector& symbols, const ParameterMap& params) { + // Setting the requested algorithm. + decltype(algorithms::complement_classical)* algo = algorithms::complement_classical; + if (!haskey(params, "algorithm")) { + throw std::runtime_error(std::to_string(__func__) + + " requires setting the \"algo\" key in the \"params\" argument; " + "received: " + std::to_string(params)); + } + + const std::string& str_algo = params.at("algorithm"); + if ("classical" == str_algo) { /* default */ } + else if ("brzozowski" == str_algo) { algo = algorithms::complement_brzozowski; } + else { + throw std::runtime_error(std::to_string(__func__) + + " received an unknown value of the \"algo\" key: " + str_algo); + } + + return algo(aut, symbols); +} diff --git a/src/cntnfa/concatenation.cc b/src/cntnfa/concatenation.cc new file mode 100644 index 000000000..d318f019b --- /dev/null +++ b/src/cntnfa/concatenation.cc @@ -0,0 +1,135 @@ +/* cntnfa-concatenation.cc -- Concatenation of NFAs + */ + +// MATA headers +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/algorithms.hh" + +using namespace mata::cntnfa; + +namespace mata::cntnfa { + +Cntnfa concatenate(const Cntnfa& lhs, const Cntnfa& rhs, bool use_epsilon, + StateRenaming* lhs_state_renaming, StateRenaming* rhs_state_renaming) { + return algorithms::concatenate_eps(lhs, rhs, EPSILON, use_epsilon, lhs_state_renaming, rhs_state_renaming); +} + +Cntnfa& Cntnfa::concatenate(const Cntnfa& aut) { + size_t n = this->num_of_states(); + auto upd_fnc = [&](State st) { + return st + n; + }; + + // copy the information about aut to save the case when this is the same object as aut. + utils::SparseSet aut_initial = aut.initial; + utils::SparseSet aut_final = aut.final; + size_t aut_n = aut.num_of_states(); + + this->delta.allocate(n); + this->delta.append(aut.delta.renumber_targets(upd_fnc)); + + // set accepting states + utils::SparseSet new_fin{}; + new_fin.reserve(n+aut_n); + for(const State& aut_fin : aut_final) { + new_fin.insert(upd_fnc(aut_fin)); + } + + // connect both parts + for(const State& ini : aut_initial) { + const StatePost& ini_post = this->delta[upd_fnc(ini)]; + // is ini state also final? + bool is_final = aut_final[ini]; + for(const State& fin : this->final) { + if(is_final) { + new_fin.insert(fin); + } + for(const SymbolPost& ini_mv : ini_post) { + // TODO: this should be done efficiently in a delta method + // TODO: in fact it is not efficient for now + for(const auto& dest : ini_mv.targets) { + this->delta.add(fin, ini_mv.symbol, dest); + } + } + } + } + this->final = new_fin; + return *this; +} + +Cntnfa algorithms::concatenate_eps(const Cntnfa& lhs, const Cntnfa& rhs, const Symbol& epsilon, bool use_epsilon, + StateRenaming* lhs_state_renaming, StateRenaming* rhs_state_renaming) { + // Compute concatenation of given automata. + // Concatenation will proceed in the order of the passed automata: Result is 'lhs . rhs'. + + if (lhs.num_of_states() == 0 || rhs.num_of_states() == 0 || lhs.initial.empty() || lhs.final.empty() || + rhs.initial.empty() || rhs.final.empty()) { + return Cntnfa{}; + } + + const unsigned long lhs_states_num{lhs.num_of_states() }; + const unsigned long rhs_states_num{rhs.num_of_states() }; + Cntnfa result{}; // Concatenated automaton. + StateRenaming _lhs_states_renaming{}; // Map mapping rhs states to result states. + StateRenaming _rhs_states_renaming{}; // Map mapping rhs states to result states. + + const size_t result_num_of_states{lhs_states_num + rhs_states_num}; + if (result_num_of_states == 0) { return Cntnfa{}; } + + // Map lhs states to result states. + _lhs_states_renaming.reserve(lhs_states_num); + Symbol result_state_index{ 0 }; + for (State lhs_state{ 0 }; lhs_state < lhs_states_num; ++lhs_state) { + _lhs_states_renaming.insert(std::make_pair(lhs_state, result_state_index)); + ++result_state_index; + } + // Map rhs states to result states. + _rhs_states_renaming.reserve(rhs_states_num); + for (State rhs_state{ 0 }; rhs_state < rhs_states_num; ++rhs_state) { + _rhs_states_renaming.insert(std::make_pair(rhs_state, result_state_index)); + ++result_state_index; + } + + result = Cntnfa(); + result.delta = lhs.delta; + result.initial = lhs.initial; + result.add_state(result_num_of_states-1); + + // Add epsilon transitions connecting lhs and rhs automata. + // The epsilon transitions lead from lhs original final states to rhs original initial states. + for (const auto& lhs_final_state: lhs.final) { + for (const auto& rhs_initial_state: rhs.initial) { + result.delta.add(lhs_final_state, epsilon, + Target(_rhs_states_renaming[rhs_initial_state])); + } + } + + // Make result final states. + for (const auto& rhs_final_state: rhs.final) + { + result.final.insert(_rhs_states_renaming[rhs_final_state]); + } + + // Add rhs transitions to the result. + for (State rhs_state{ 0 }; rhs_state < rhs_states_num; ++rhs_state) + { + for (const SymbolPost& rhs_move: rhs.delta.state_post(rhs_state)) + { + for (const auto& rhs_state_to: rhs_move.targets) + { + result.delta.add(_rhs_states_renaming[rhs_state], + rhs_move.symbol, + Target(_rhs_states_renaming[rhs_state_to])); + } + } + } + + if (!use_epsilon) { + result.remove_epsilon(); + } + if (lhs_state_renaming != nullptr) { *lhs_state_renaming = _lhs_states_renaming; } + if (rhs_state_renaming != nullptr) { *rhs_state_renaming = _rhs_states_renaming; } + return result; +} // concatenate_eps(). + +} // namespace mata::cntnfa. diff --git a/src/cntnfa/delta.cc b/src/cntnfa/delta.cc new file mode 100644 index 000000000..d9d63df9c --- /dev/null +++ b/src/cntnfa/delta.cc @@ -0,0 +1,778 @@ +/* delta.cc -- Operations on Delta. + */ + +#include +#include +#include + +#include "mata/cntnfa/types.hh" +#include "mata/utils/sparse-set.hh" +#include "mata/cntnfa/delta.hh" + +using namespace mata::utils; +using namespace mata::cntnfa; +using mata::Symbol; + +using StateBoolArray = std::vector; ///< Bool array for states in the automaton. + +SymbolPost& SymbolPost::operator=(SymbolPost&& rhs) noexcept { + if (*this != rhs) { + symbol = rhs.symbol; + targets = std::move(rhs.targets); + } + return *this; +} + +void SymbolPost::insert(State s) { + if(targets.empty() || targets.back() < s) { + targets.push_back(s); + return; + } + // Find the place where to put the element (if not present). + // insert to OrdVector without the searching of a proper position inside insert(const Key&x). + auto it = std::lower_bound(targets.begin(), targets.end(), s); + if (it == targets.end() || *it != s) { + targets.insert(it, s); + } +} + +//TODO: slow! This should be doing merge, not inserting one by one. +void SymbolPost::insert(const StateSet& states) { + for (State s : states) { + insert(s); + } +} + +StatePost::const_iterator Delta::epsilon_symbol_posts(const State state, const Symbol epsilon) const { + return epsilon_symbol_posts(state_post(state), epsilon); +} + +StatePost::const_iterator Delta::epsilon_symbol_posts(const StatePost& state_post, const Symbol epsilon) { + if (!state_post.empty()) { + if (epsilon == EPSILON) { + const auto& back = state_post.back(); + if (back.symbol == epsilon) { return std::prev(state_post.end()); } + } else { return state_post.find(SymbolPost(epsilon)); } + } + return state_post.end(); +} + +std::vector Delta::get_transitions_to(const State state_to) const { + std::vector transitions_to_state{}; + const size_t num_of_states{ this->num_of_states() }; + for (State state_from{ 0 }; state_from < num_of_states; ++state_from) { + for (const SymbolPost& state_from_move: state_post(state_from)) { + const auto target_state{ state_from_move.targets.find(state_to) }; + if (target_state != state_from_move.targets.end()) { + transitions_to_state.emplace_back(state_from, state_from_move.symbol, state_to); + } + } + } + return transitions_to_state; +} + +void Delta::add(State source, Symbol symbol, Target target) { + const State max_state{ std::max(source, target.state) }; + + if (max_state >= state_posts_.size()) { + reserve_on_insert(state_posts_, max_state); + state_posts_.resize((max_state + 1)); + } + + StatePost& state_transitions{ state_posts_[source] }; + + if (state_transitions.empty()) { + state_transitions.insert({ symbol, target }); + } else if (state_transitions.back().symbol < symbol) { + state_transitions.insert({ symbol, target }); + } else { + const auto symbol_transitions{ state_transitions.find(SymbolPost{ symbol }) }; + if (symbol_transitions != state_transitions.end()) { + // Add transition with symbol already used on transitions from state_from. + symbol_transitions->insert(target); + } else { + // Add transition to a new Move struct with symbol yet unused on transitions from state_from. + const SymbolPost new_symbol_transitions{ symbol, target }; + state_transitions.insert(new_symbol_transitions); + } + } +} + +void Delta::add(State source, Symbol symbol, State target) { + add(source, symbol, Target(target)); +} + +void Delta::add(const State source, const Symbol symbol, const TargetSet& targets) { + if(targets.empty()) { + return; + } + + const State max_state{ std::max(source, targets.back().state) }; + if (max_state >= state_posts_.size()) { + reserve_on_insert(state_posts_, max_state + 1); + state_posts_.resize(max_state + 1); + } + + StatePost& state_transitions{ state_posts_[source] }; + + if (state_transitions.empty()) { + state_transitions.insert({ symbol, targets }); + } else if (state_transitions.back().symbol < symbol) { + state_transitions.insert({ symbol, targets }); + } else { + const auto symbol_transitions{ state_transitions.find(symbol) }; + if (symbol_transitions != state_transitions.end()) { + // Add transition with symbolOnTransition already used on transitions from state_from. + symbol_transitions->insert(targets); + } else { + // Add transition to a new Move struct with symbol yet unused on transitions from state_from. + // Move new_symbol_transitions{ symbol, states }; + state_transitions.insert(SymbolPost{ symbol, targets}); + } + } +} + +void Delta::add(const State source, const Symbol symbol, const StateSet& targets) { + add(source, symbol, TargetSet(targets)); +} + +void Delta::remove(State source, Symbol symbol, Target target) { + if (source >= state_posts_.size()) { + return; + } + + StatePost& state_transitions{ state_posts_[source] }; + if (state_transitions.empty()) { + throw std::invalid_argument( + "Transition [" + std::to_string(source) + ", " + std::to_string(symbol) + ", " + + std::to_string(target) + "] does not exist."); + } else if (state_transitions.back().symbol < symbol) { + throw std::invalid_argument( + "Transition [" + std::to_string(source) + ", " + std::to_string(symbol) + ", " + + std::to_string(target) + "] does not exist."); + } else { + const auto symbol_transitions{ state_transitions.find(symbol) }; + if (symbol_transitions == state_transitions.end()) { + throw std::invalid_argument( + "Transition [" + std::to_string(source) + ", " + std::to_string(symbol) + ", " + + std::to_string(target) + "] does not exist."); + } else { + symbol_transitions->erase(target); + if (symbol_transitions->empty()) { + state_posts_[source].erase(*symbol_transitions); + } + } + } +} + +bool Delta::contains(State source, Symbol symbol, Target target) const +{ + if (state_posts_.empty()) { + return false; + } + + if (state_posts_.size() <= source) + return false; + + const StatePost& tl = state_posts_[source]; + if (tl.empty()) { + return false; + } + + auto symbol_transitions{ tl.find(SymbolPost{ symbol }) }; + if (symbol_transitions == tl.cend()) { + return false; + } + + return symbol_transitions->targets.find(target) != symbol_transitions->targets.end(); +} + +bool Delta::contains(const Transition& transition) const { + return contains(transition.source, transition.symbol, transition.target); +} + +size_t Delta::num_of_transitions() const { + size_t number_of_transitions{ 0 }; + for (const StatePost& state_post: state_posts_) { + for (const SymbolPost& symbol_post: state_post) { + number_of_transitions += symbol_post.num_of_targets(); + } + } + return number_of_transitions; +} + +bool Delta::empty() const { + for (const StatePost& state_post: state_posts_) { + if (!state_post.empty()) { return false; } + } + return true; +} + +void Delta::append(const std::vector& post_vector) { + for(const StatePost& pst : post_vector) { + this->state_posts_.push_back(pst); + } +} + +void Delta::append_remapped(const Delta& other, State state_offset, size_t annotation_set_offset) { + for (State s = 0; s < other.num_of_states(); ++s) { + State new_source = s + state_offset; + const auto& state_post = other[s]; + + for (const auto& symbol_post : state_post) { + Symbol symbol = symbol_post.symbol; + AnnotationStateSet new_targets; + + for (const auto& target : symbol_post.targets) { + State new_target = target.state + state_offset; + size_t new_ann_id = (target.annotations_id == UNDEFINED_ANNOTATIONS) + ? UNDEFINED_ANNOTATIONS + : target.annotations_id + annotation_set_offset; + new_targets.push_back({new_target, new_ann_id}); + } + + this->add(new_source, symbol, new_targets); + } + } +} + +Delta::Transitions::const_iterator::const_iterator(const Delta& delta): delta_{ &delta } { + const size_t post_size = delta_->num_of_states(); + for (size_t i = 0; i < post_size; ++i) { + if (!(*delta_)[i].empty()) { + current_state_ = i; + state_post_it_ = (*delta_)[i].begin(); + symbol_post_it_ = state_post_it_->targets.begin(); + transition_.source = current_state_; + transition_.symbol = state_post_it_->symbol; + transition_.target = *symbol_post_it_; + return; + } + } + + // No transition found, delta contains only empty state posts. + is_end_ = true; +} + +Delta::Transitions::const_iterator::const_iterator(const Delta& delta, State current_state) + : delta_{ &delta }, current_state_{ current_state } { + const size_t post_size = delta_->num_of_states(); + for (State source{ current_state_ }; source < post_size; ++source) { + const StatePost& state_post{ delta_->state_post(source) }; + if (!state_post.empty()) { + current_state_ = source; + state_post_it_ = state_post.begin(); + symbol_post_it_ = state_post_it_->targets.begin(); + transition_.source = current_state_; + transition_.symbol = state_post_it_->symbol; + transition_.target = *symbol_post_it_; + return; + } + } + + // No transition found, delta from the current state contains only empty state posts. + is_end_ = true; +} + +Delta::Transitions::const_iterator& Delta::Transitions::const_iterator::operator++() { + assert(delta_->begin() != delta_->end()); + + ++symbol_post_it_; + if (symbol_post_it_ != state_post_it_->targets.end()) { + transition_.target = *symbol_post_it_; + return *this; + } + + ++state_post_it_; + if (state_post_it_ != (*delta_)[current_state_].cend()) { + symbol_post_it_ = state_post_it_->targets.begin(); + transition_.symbol = state_post_it_->symbol; + transition_.target = *symbol_post_it_; + return *this; + } + + const size_t state_posts_size{ delta_->num_of_states() }; + do { // Skip empty posts. + ++current_state_; + } while (current_state_ < state_posts_size && (*delta_)[current_state_].empty()); + if (current_state_ >= state_posts_size) { + is_end_ = true; + return *this; + } + + const StatePost& state_post{ (*delta_)[current_state_] }; + state_post_it_ = state_post.begin(); + symbol_post_it_ = state_post_it_->targets.begin(); + + transition_.source = current_state_; + transition_.symbol = state_post_it_->symbol; + transition_.target = *symbol_post_it_; + + return *this; +} + +const Delta::Transitions::const_iterator Delta::Transitions::const_iterator::operator++(int) { + const Delta::Transitions::const_iterator tmp{ *this }; + ++(*this); + return tmp; +} + +bool Delta::Transitions::const_iterator::operator==(const Delta::Transitions::const_iterator& other) const { + if (is_end_ && other.is_end_) { + return true; + } else if ((is_end_ && !other.is_end_) || (!is_end_ && other.is_end_)) { + return false; + } else { + return current_state_ == other.current_state_ && state_post_it_ == other.state_post_it_ + && symbol_post_it_ == other.symbol_post_it_; + } +} + +std::vector Delta::renumber_targets(const std::function& target_renumberer) const { + std::vector copied_state_posts; + copied_state_posts.reserve(num_of_states()); + for(const StatePost& state_post: state_posts_) { + StatePost copied_state_post; + copied_state_post.reserve(state_post.size()); + for(const SymbolPost& symbol_post: state_post) { + StateSet copied_targets; + copied_targets.reserve(symbol_post.num_of_targets()); + for(const auto& state: symbol_post.targets) { + copied_targets.push_back(std::move(target_renumberer(state))); + } + copied_state_post.push_back(SymbolPost(symbol_post.symbol, copied_targets)); + } + copied_state_posts.emplace_back(copied_state_post); + } + return copied_state_posts; +} + +StatePost& Delta::mutable_state_post(State q) { + if (q >= state_posts_.size()) { + utils::reserve_on_insert(state_posts_, q); + const size_t new_size{ q + 1 }; + state_posts_.resize(new_size); + } + + return state_posts_[q]; +} + +// Note: Changed std::vector to std::vector. +void Delta::defragment(const BoolVector& is_staying, const std::vector& renaming) { + //TODO: this function seems to be unreadable, should be refactored, maybe into several functions with a clear functionality? + + //first, indexes of post are filtered (places of to be removed states are taken by states on their right) + size_t move_index{ 0 }; + std::erase_if(state_posts_, + [&](StatePost&) -> bool { + size_t prev{ move_index }; + ++move_index; + return !is_staying[prev]; + } + ); + + //this iterates through every post and every move, filters and renames states, + //and then removes moves that became empty. + for (State q=0,size=state_posts_.size(); q < size; ++q) { + StatePost & p = mutable_state_post(q); + for (auto move = p.begin(); move < p.end(); ++move) { + move->targets.erase( + std::remove_if(move->targets.begin(), move->targets.end(), [&](State q) -> bool { + return !is_staying[q]; + }), + move->targets.end() + ); + move->targets.rename(renaming); + } + p.erase( + std::remove_if(p.begin(), p.end(), [&](SymbolPost& move) -> bool { + return move.targets.empty(); + }), + p.end() + ); + } +} + +bool Delta::operator==(const Delta& other) const { + Delta::Transitions this_transitions{ transitions() }; + Delta::Transitions::const_iterator this_transitions_it{ this_transitions.begin() }; + const Delta::Transitions::const_iterator this_transitions_end{ this_transitions.end() }; + Delta::Transitions other_transitions{ other.transitions() }; + Delta::Transitions::const_iterator other_transitions_it{ other_transitions.begin() }; + const Delta::Transitions::const_iterator other_transitions_end{ other_transitions.end() }; + while (this_transitions_it != this_transitions_end) { + if (other_transitions_it == other_transitions_end || *this_transitions_it != *other_transitions_it) { + return false; + } + ++this_transitions_it; + ++other_transitions_it; + } + return other_transitions_it == other_transitions_end; +} + +///Returns an iterator to the smallest epsilon, or end() if there is no epsilon +///Searches from the end of the vector of SymbolPosts, since epsilons are at the end and they are typically few, mostly 1. +StatePost::const_iterator StatePost::first_epsilon_it(Symbol first_epsilon) const { + auto end_it = end(); + auto it = end_it; + while (it != begin()) { + --it; + if (it->symbol < first_epsilon) { //is it a normal symbol already? + return it + 1; // Return the previous position, the smallest epsilon or end(). + } + } + + if (it != end_it && it->symbol >= first_epsilon) //special case when begin is the smallest epsilon (since the while loop ended before the step back) + return it; + + return end_it; +} + +StatePost::Moves::const_iterator::const_iterator( + const StatePost& state_post, const StatePost::const_iterator symbol_post_it, + const StatePost::const_iterator symbol_post_end) + : state_post_{ &state_post }, symbol_post_it_{ symbol_post_it }, symbol_post_end_{ symbol_post_end } { + if (symbol_post_it_ == symbol_post_end_) { + is_end_ = true; + return; + } + + move_.symbol = symbol_post_it_->symbol; + target_it_ = symbol_post_it_->targets.cbegin(); + move_.target = *target_it_; +} + +StatePost::Moves::const_iterator::const_iterator(const StatePost& state_post) + : state_post_{ &state_post }, symbol_post_it_{ state_post.begin() }, symbol_post_end_{ state_post.end() } { + if (symbol_post_it_ == symbol_post_end_) { + is_end_ = true; + return; + } + + move_.symbol = symbol_post_it_->symbol; + target_it_ = symbol_post_it_->targets.cbegin(); + move_.target = *target_it_; +} + +StatePost::Moves::const_iterator& StatePost::Moves::const_iterator::operator++() { + ++target_it_; + if (target_it_ != symbol_post_it_->targets.end()) { + move_.target = *target_it_; + return *this; + } + + // Iterate over to the next symbol post, which can be either an end iterator, or symbol post whose + // symbol <= symbol_post_end_. + ++symbol_post_it_; + if (symbol_post_it_ == symbol_post_end_) { + is_end_ = true; + return *this; + } + // The current symbol post is valid (not equal symbol_post_end_). + move_.symbol = symbol_post_it_->symbol; + target_it_ = symbol_post_it_->targets.begin(); + move_.target = *target_it_; + return *this; +} + +const StatePost::Moves::const_iterator StatePost::Moves::const_iterator::operator++(int) { + const StatePost::Moves::const_iterator tmp{ *this }; + ++(*this); + return tmp; +} + +bool StatePost::Moves::const_iterator::operator==(const StatePost::Moves::const_iterator& other) const { + if (is_end_ && other.is_end_) { + return true; + } else if ((is_end_ && !other.is_end_) || (!is_end_ && other.is_end_)) { + return false; + } + return symbol_post_it_ == other.symbol_post_it_ && target_it_ == other.target_it_ + && symbol_post_end_ == other.symbol_post_end_; +} + +size_t StatePost::num_of_moves() const { + size_t counter{ 0 }; + for (const SymbolPost& symbol_post: *this) { + counter += symbol_post.num_of_targets(); + } + return counter; +} + +StatePost::Moves& StatePost::Moves::operator=(StatePost::Moves&& other) noexcept { + if (&other != this) { + state_post_ = other.state_post_; + symbol_post_it_ = std::move(other.symbol_post_it_); + symbol_post_end_ = std::move(other.symbol_post_end_); + } + return *this; +} + +StatePost::Moves& StatePost::Moves::operator=(const Moves& other) noexcept { + if (&other != this) { + state_post_ = other.state_post_; + symbol_post_it_ = other.symbol_post_it_; + symbol_post_end_ = other.symbol_post_end_; + } + return *this; +} + +StatePost::Moves StatePost::moves( + const StatePost::const_iterator symbol_post_it, const StatePost::const_iterator symbol_post_end) const { + return { *this, symbol_post_it, symbol_post_end }; +} + +StatePost::Moves StatePost::moves_epsilons(const Symbol first_epsilon) const { + return { *this, first_epsilon_it(first_epsilon), cend() }; +} + +StatePost::Moves StatePost::moves_symbols(const Symbol last_symbol) const { + if (last_symbol == EPSILON) { throw std::runtime_error("Using default epsilon as a last symbol to iterate over."); } + return { *this, cbegin(), first_epsilon_it(last_symbol + 1) }; +} + +StatePost::Moves::const_iterator StatePost::Moves::begin() const { + return { *state_post_, symbol_post_it_, symbol_post_end_ }; +} + +StatePost::Moves::const_iterator StatePost::Moves::end() const { return const_iterator{}; } + +Delta::Transitions Delta::transitions() const { return Transitions{ this }; } + +Delta::Transitions::const_iterator Delta::Transitions::begin() const { return const_iterator{ *delta_ }; } +Delta::Transitions::const_iterator Delta::Transitions::end() const { return const_iterator{}; } + +StatePost::Moves::Moves( + const StatePost& state_post, StatePost::const_iterator symbol_post_it, StatePost::const_iterator symbol_post_end) + : state_post_{ &state_post }, symbol_post_it_{ symbol_post_it }, symbol_post_end_{ symbol_post_end } {} + +void Delta::add_symbols_to(OnTheFlyAlphabet& target_alphabet) const { + size_t aut_num_of_states{ num_of_states() }; + for (mata::cntnfa::State state{ 0 }; state < aut_num_of_states; ++state) { + for (const SymbolPost& move: state_post(state)) { + target_alphabet.update_next_symbol_value(move.symbol); + target_alphabet.try_add_new_symbol(std::to_string(move.symbol), move.symbol); + } + } +} + +OrdVector Delta::get_used_symbols() const { + //TODO: look at the variants in profiling (there are tests in tests-nfa-profiling.cc), + // for instance figure out why NumberPredicate and OrdVector are slow, + // try also with _STATIC_DATA_STRUCTURES_, it changes things. + + //below are different variant, with different data structures for accumulating symbols, + //that then must be converted to an OrdVector + //measured are times with "mata::cntnfa::get_used_symbols speed, harder", "[.profiling]" now on line 104 of nfa-profiling.cc + + //WITH VECTOR (4.434 s) + return get_used_symbols_vec(); + + //WITH SET (26.5 s) + //auto from_set = get_used_symbols_set(); + //return utils::OrdVector (from_set .begin(),from_set.end()); + + //WITH NUMBER PREDICATE (4.857s) (NP removed) + //return utils::OrdVector(get_used_symbols_np().get_elements()); + + //WITH SPARSE SET (haven't tried) + //return utils::OrdVector(get_used_symbols_sps()); + + //WITH BOOL VECTOR (error !!!!!!!): + //return utils::OrdVector(utils::NumberPredicate(get_used_symbols_bv())); + + //WITH BOOL VECTOR (1.9s): (The fastest, it seems.) + // However, it will try to allocate a vector indexed by the symbols. If there are epsilons in the automaton, + // for example, the bool vector implementation will implode. + // std::vector bv{ get_used_symbols_bv() }; + // utils::OrdVector ov{}; + // const size_t bv_size{ bv.size() }; + // for (Symbol i{ 0 }; i < bv_size; ++i) { if (bv[i]) { ov.push_back(i); } } + // return ov; + + ///WITH BOOL VECTOR, DIFFERENT VARIANT? (1.9s): + //std::vector bv = get_used_symbols_bv(); + //std::vector v(std::count(bv.begin(), bv.end(), true)); + //return utils::OrdVector(v); + + //WITH CHAR VECTOR (should be the fastest, haven't tried in this branch): + //BEWARE: failing in one noodlificatoin test ("Simple automata -- epsilon result") ... strange + //BoolVector chv = get_used_symbols_chv(); + //utils::OrdVector ov; + //for(Symbol i = 0;i Delta::get_used_symbols_vec() const { +#ifdef _STATIC_STRUCTURES_ + static std::vector symbols{}; + symbols.clear(); +#else + std::vector symbols{}; +#endif + for (const StatePost& state_post: state_posts_) { + for (const SymbolPost & symbol_post: state_post) { + utils::reserve_on_insert(symbols); + symbols.push_back(symbol_post.symbol); + } + } + utils::OrdVector sorted_symbols(symbols); + return sorted_symbols; +} + +// returns symbols appearing in Delta, inserts to a std::set +std::set Delta::get_used_symbols_set() const { + //static should prevent reallocation, seems to speed things up a little +#ifdef _STATIC_STRUCTURES_ + static std::set symbols; + symbols.clear(); +#else + static std::set symbols{}; +#endif + for (const StatePost& state_post: state_posts_) { + for (const SymbolPost& symbol_post: state_post) { + symbols.insert(symbol_post.symbol); + } + } + return symbols; + //utils::OrdVector sorted_symbols(symbols.begin(),symbols.end()); + //return sorted_symbols; +} + +// returns symbols appearing in Delta, adds to NumberPredicate, +// Seems to be the fastest option, but could have problems with large maximum symbols +mata::utils::SparseSet Delta::get_used_symbols_sps() const { +#ifdef _STATIC_STRUCTURES_ + //static seems to speed things up a little + static utils::SparseSet symbols(64,false); + symbols.clear(); +#else + utils::SparseSet symbols(64); +#endif + //symbols.dont_track_elements(); + for (const StatePost& state_post: state_posts_) { + for (const SymbolPost & symbol_post: state_post) { + symbols.insert(symbol_post.symbol); + } + } + //TODO: is it necessary to return ordered vector? Would the number predicate suffice? + return symbols; +} + +// returns symbols appearing in Delta, adds to NumberPredicate, +// Seems to be the fastest option, but could have problems with large maximum symbols +std::vector Delta::get_used_symbols_bv() const { +#ifdef _STATIC_STRUCTURES_ + //static seems to speed things up a little + static std::vector symbols(64, false); + symbols.clear(); +#else + std::vector symbols(64, false); +#endif + //symbols.dont_track_elements(); + for (const StatePost& state_post: state_posts_) { + for (const SymbolPost& symbol_post: state_post) { + const size_t capacity{ symbol_post.symbol + 1 }; + reserve_on_insert(symbols, capacity); + if (symbols.size() < capacity) { + symbols.resize(capacity); + } + symbols[symbol_post.symbol] = true; + } + } + return symbols; +} + +mata::BoolVector Delta::get_used_symbols_chv() const { +#ifdef _STATIC_STRUCTURES_ + //static seems to speed things up a little + static BoolVector symbols(64,false); + symbols.clear(); +#else + BoolVector symbols(64,false); +#endif + //symbols.dont_track_elements(); + for (const StatePost& state_post: state_posts_) { + for (const SymbolPost& symbol_post: state_post) { + reserve_on_insert(symbols,symbol_post.symbol); + symbols[symbol_post.symbol] = true; + } + } + //TODO: is it necessary to return ordered vector? Would the number predicate suffice? + return symbols; +} + +Symbol Delta::get_max_symbol() const { + Symbol max{ 0 }; + for (const StatePost& state_post: state_posts_) { + for (const SymbolPost& symbol_post: state_post) { + if (symbol_post.symbol > max) { max = symbol_post.symbol; } + } + } + return max; +} + +StateSet SynchronizedExistentialSymbolPostIterator::unify_targets() const { + // TODO: decide which version performs the best. + + if(!is_synchronized()) { return {}; } + + StateSet unified_targets{}; + + // Version with synchronized iterator. + // static utils::SynchronizedExistentialIterator sync_iterator; + // sync_iterator.reset(); + // size_t all_targets_size{ 0 }; + // const std::vector& current_symbol_post_its{ this->get_current() }; + // sync_iterator.reserve(current_symbol_post_its.size()); + // for (const auto symbol_post_it: current_symbol_post_its) { + // sync_iterator.push_back(symbol_post_it->cbegin(), symbol_post_it->cend()); + // all_targets_size += symbol_post_it->num_of_targets(); + // } + // unified_targets.reserve(all_targets_size); + // while (sync_iterator.advance()) { unified_targets.push_back(*sync_iterator.get_current_minimum()); } + + // Version with set union. + // for (const auto& symbol_post_it: get_current()) { + // unified_targets.insert(symbol_post_it->targets); + // } + + // Version with priority queue. + // Note: Changed to TargetSet::const_iterator instead of StateSet::const_iterator. + using TargetSetBeginEndPair = std::pair; + auto compare = [](const auto& a, const auto& b) { return *(a.first) > *(b.first); }; + std::priority_queue, decltype(compare) > queue(compare); + for (const StatePost::const_iterator& symbol_post_it: get_current()) { + queue.emplace(symbol_post_it->cbegin(), symbol_post_it->cend()); + } + unified_targets.reserve(32); + while (!queue.empty()) { + auto item = queue.top(); + queue.pop(); + if (unified_targets.empty() || unified_targets.back() != *(item.first)) { + unified_targets.push_back(*(item.first)); + } + if (++item.first != item.second) { queue.emplace(item); } + } + + return unified_targets; +} + +bool SynchronizedExistentialSymbolPostIterator::synchronize_with(const Symbol sync_symbol) { + do { + if (is_synchronized()) { + auto current_min_symbol_post_it = get_current_minimum(); + if (current_min_symbol_post_it->symbol >= sync_symbol) { break; } + } + } while (advance()); + return is_synchronized() && get_current_minimum()->symbol == sync_symbol; +} + +bool SynchronizedExistentialSymbolPostIterator::synchronize_with(const SymbolPost& sync) { + return synchronize_with(sync.symbol); +} diff --git a/src/cntnfa/inclusion.cc b/src/cntnfa/inclusion.cc new file mode 100644 index 000000000..134a16f51 --- /dev/null +++ b/src/cntnfa/inclusion.cc @@ -0,0 +1,308 @@ +/* cntnfa-incl.cc -- NFA language inclusion + */ + +// MATA headers +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/algorithms.hh" +#include "mata/utils/sparse-set.hh" + +using namespace mata::cntnfa; +using namespace mata::utils; + +/// naive language inclusion check (complementation + intersection + emptiness) +bool mata::cntnfa::algorithms::is_included_naive( + const Cntnfa &smaller, + const Cntnfa &bigger, + const Alphabet *const alphabet,//TODO: this should not be needed, likewise for equivalence + Run *cex) { // {{{ + Cntnfa bigger_cmpl; + if (alphabet == nullptr) { + bigger_cmpl = complement(bigger, create_alphabet(smaller, bigger)); + } else { + bigger_cmpl = complement(bigger, *alphabet); + } + + std::unordered_map,State> prod_map; + Cntnfa nfa_isect = intersection(smaller, bigger_cmpl, Limits::max_symbol, &prod_map); + + bool result = nfa_isect.is_lang_empty(cex); + if (cex != nullptr && !result) { + std::unordered_map nfa_isect_state_to_smaller_state; + for (const auto& prod_map_item : prod_map) { + nfa_isect_state_to_smaller_state[prod_map_item.second] = prod_map_item.first.first; + } + for (State& path_state : cex->path) { + path_state = nfa_isect_state_to_smaller_state[path_state]; + } + } + return result; +} // is_included_naive }}} + + +/// language inclusion check using Antichains +// TODO, what about to construct the separator from this? +bool mata::cntnfa::algorithms::is_included_antichains( + const Cntnfa& smaller, + const Cntnfa& bigger, + const Alphabet* const alphabet, //TODO: this parameter is not used + Run* cex) +{ // {{{ + (void)alphabet; + + // TODO: Decide what is the best optimization for inclusion. + + using ProdStateType = std::tuple; + using ProdStatesType = std::vector; + // ProcessedType is indexed by states of the smaller nfa + // tailored for pure antichain approach ... the simulation-based antichain will not work (without changes). + using ProcessedType = std::vector; + + auto subsumes = [](const ProdStateType& lhs, const ProdStateType& rhs) { + if (std::get<0>(lhs) != std::get<0>(rhs)) { + return false; + } + + const StateSet& lhs_bigger = std::get<1>(lhs); + const StateSet& rhs_bigger = std::get<1>(rhs); + + //TODO: Can this be done faster using more heuristics? E.g., compare the last elements first ... + //TODO: Try BDDs! What about some abstractions? + return lhs_bigger.is_subset_of(rhs_bigger); + }; + + + // initialize + ProdStatesType worklist{};//Pairs (q,S) to be processed. It sometimes gives a huge speed-up when they are kept sorted by the size of S, + // worklist.reserve(32); + // so those with smaller popped for processing first. + ProcessedType processed(smaller.num_of_states()); // Allocate to the number of states of the smaller nfa. + // The pairs of each state are also kept sorted. It allows slightly faster antichain pruning - no need to test inclusion in sets that have less elements. + + //Is |S| < |S'| for the inut pairs (q,S) and (q',S')? + // auto smaller_set = [](const ProdStateType & a, const ProdStateType & b) { return std::get<1>(a).size() < std::get<1>(b).size(); }; + + std::vector distances_smaller = smaller.distances_to_final(); + std::vector distances_bigger = bigger.distances_to_final(); + + // auto closer_dist = [&](const ProdStateType & a, const ProdStateType & b) { + // return distances_smaller[a.first] < distances_smaller[b.first]; + // }; + + // auto closer_smaller = [&](const ProdStateType & a, const ProdStateType & b) { + // if (distances_smaller[a.first] != distances_smaller[b.first]) + // return distances_smaller[a.first] < distances_smaller[b.first]; + // else + // return a.second.size() < b.second.size(); + // }; + + // auto smaller_closer = [&](const ProdStateType & a, const ProdStateType & b) { + // if (a.second.size() != b.second.size()) + // return a.second.size() < b.second.size(); + // else + // return distances_smaller[a.first] < distances_smaller[b.first]; + // }; + + auto min_dst = [&](const StateSet& set) { + if (set.empty()) return Limits::max_state; + return distances_bigger[*std::min_element(set.begin(), set.end(), [&](const State a,const State b){return distances_bigger[a] < distances_bigger[b];})]; + }; + + auto lengths_incompatible = [&](const ProdStateType& pair) { + return distances_smaller[std::get<0>(pair)] < std::get<2>(pair); + }; + + auto insert_to_pairs = [&](ProdStatesType & pairs,const ProdStateType & pair) { + // auto it = std::lower_bound(pairs.begin(), pairs.end(), pair, smaller_set); + // auto it = std::lower_bound(pairs.begin(), pairs.end(), pair, closer_dist); + // auto it = std::lower_bound(pairs.begin(), pairs.end(), pair, smaller_closer); + // auto it = std::lower_bound(pairs.begin(), pairs.end(), pair, closer_smaller); + // pairs.insert(it,pair); + pairs.push_back(pair); + // std::sort(pairs.begin(), pairs.end(), smaller_closer); + }; + + // 'paths[s] == t' denotes that state 's' was accessed from state 't', + // 'paths[s] == s' means that 's' is an initial state + std::map> paths; + + // check initial states first // TODO: this would be done in the main loop as the first thing anyway? + for (const auto& state : smaller.initial) { + if (smaller.final[state] && + are_disjoint(bigger.initial, bigger.final)) + { + if (cex != nullptr) { cex->word.clear(); cex->path = {state}; } + return false; + } + + StateSet bigger_state_set{ bigger.initial }; + const ProdStateType st = std::tuple(state, bigger_state_set, min_dst(bigger_state_set)); + insert_to_pairs(worklist, st); + insert_to_pairs(processed[state],st); + + if (cex != nullptr) + paths.insert({ st, {st, 0}}); + } + + //For synchronised iteration over the set of states + SynchronizedExistentialSymbolPostIterator sync_iterator; + + // We use DFS strategy for the worklist processing + while (!worklist.empty()) { + // get a next product state + ProdStateType prod_state = *worklist.rbegin(); + worklist.pop_back(); + + const State& smaller_state = std::get<0>(prod_state); + const StateSet& bigger_set = std::get<1>(prod_state); + + sync_iterator.reset(); + for (State q: bigger_set) { + mata::utils::push_back(sync_iterator, bigger.delta[q]); + } + + // process transitions leaving smaller_state + for (const auto& smaller_move : smaller.delta[smaller_state]) { + const Symbol& smaller_symbol = smaller_move.symbol; + + StateSet bigger_succ = {}; + if(sync_iterator.synchronize_with(smaller_move)) { + bigger_succ = sync_iterator.unify_targets(); + } + + for (const auto& smaller_succ : smaller_move.targets) { + const ProdStateType succ = {smaller_succ, bigger_succ, min_dst(bigger_succ)}; + + if (lengths_incompatible(succ) || + (smaller.final[smaller_succ] && !bigger.final.intersects_with(bigger_succ))) + { + if (cex != nullptr) { + cex->word.push_back(smaller_symbol); + cex->path.push_back(smaller_state); + auto next_on_path = paths.find(prod_state); + while (next_on_path->second.first != next_on_path->first) + { // go back until initial state + cex->word.push_back(next_on_path->second.second); + cex->path.push_back(std::get<0>(next_on_path->second.first)); + next_on_path = paths.find(next_on_path->second.first); + } + + std::reverse(cex->word.begin(), cex->word.end()); + std::reverse(cex->path.begin(), cex->path.end()); + + // it is poosible that lengths_incompatible(succ) was true, which means that cex is not finished, we need to add some shortest accepting run from smaller_suc + Run leftover = smaller.get_shortest_accepting_run_from_state(smaller_succ, distances_smaller); + cex->word.insert(cex->word.end(), leftover.word.begin(), leftover.word.end()); + cex->path.insert(cex->path.end(), leftover.path.begin(), leftover.path.end()); + } + + return false; + } + + bool is_subsumed = false; + for (const auto& anti_state : processed[smaller_succ]) + { // trying to find in processed a smaller state than the newly created succ + // if (smaller_set(succ,anti_state)) { + // break; + // } + if (subsumes(anti_state, succ)) { + is_subsumed = true; + break; + } + } + + if (is_subsumed) { + continue; + } + + for (ProdStatesType* ds: {&processed[smaller_succ], &worklist}) { + //Pruning of processed and the worklist. + //Since they are ordered by the size of the sets, we can iterate from back, + //and as soon as we get to sets larger than succ, we can stop (larger sets cannot be subsets). + std::erase_if(*ds, [&](const auto& d){ return subsumes(succ, d); }); + // for (long it = static_cast(ds->size()-1);it>=0;--it) { + // // if (smaller_set((*ds)[static_cast(it)],succ)) + // // break; + // if (subsumes(succ, (*ds)[static_cast(it)])) { + // //Using index it instead of an iterator since erase could invalidate it (?) + // ds->erase(ds->begin() + it); + // } + // } + insert_to_pairs(*ds, succ); + } + + if(cex != nullptr) { + // also set that succ was accessed from state + paths[succ] = {prod_state, smaller_symbol}; + } + } + } + } + return true; +} // }}} + +namespace { + using AlgoType = decltype(algorithms::is_included_naive)*; + + bool compute_equivalence(const Cntnfa &lhs, const Cntnfa &rhs, const mata::Alphabet *const alphabet, const AlgoType &algo) { + //alphabet should not be needed as input parameter + if (algo(lhs, rhs, alphabet, nullptr)) { + if (algo(rhs, lhs, alphabet, nullptr)) { + return true; + } + } + + return false; + } + + AlgoType set_algorithm(const std::string &function_name, const ParameterMap ¶ms) { + if (!haskey(params, "algorithm")) { + throw std::runtime_error(function_name + + " requires setting the \"algo\" key in the \"params\" argument; " + "received: " + std::to_string(params)); + } + + decltype(algorithms::is_included_naive) *algo; + const std::string &str_algo = params.at("algorithm"); + if ("naive" == str_algo) { + algo = algorithms::is_included_naive; + } else if ("antichains" == str_algo) { + algo = algorithms::is_included_antichains; + } else { + throw std::runtime_error(std::to_string(__func__) + + " received an unknown value of the \"algo\" key: " + str_algo); + } + + return algo; + } + +} + +// The dispatching method that calls the correct one based on parameters +bool mata::cntnfa::is_included( + const Cntnfa &smaller, + const Cntnfa &bigger, + Run *cex, + const Alphabet *const alphabet, + const ParameterMap ¶ms) { // {{{ + AlgoType algo{set_algorithm(std::to_string(__func__), params)}; + return algo(smaller, bigger, alphabet, cex); +} // is_included }}} + +bool mata::cntnfa::are_equivalent(const Cntnfa& lhs, const Cntnfa& rhs, const Alphabet *alphabet, const ParameterMap& params) +{ + //TODO: add comment on what this is doing, what is __func__ ... + AlgoType algo{ set_algorithm(std::to_string(__func__), params) }; + + if (params.at("algorithm") == "naive") { + if (alphabet == nullptr) { + const auto computed_alphabet{create_alphabet(lhs, rhs) }; + return compute_equivalence(lhs, rhs, &computed_alphabet, algo); + } + } + + return compute_equivalence(lhs, rhs, alphabet, algo); +} + +bool mata::cntnfa::are_equivalent(const Cntnfa& lhs, const Cntnfa& rhs, const ParameterMap& params) { + return are_equivalent(lhs, rhs, nullptr, params); +} diff --git a/src/cntnfa/operations.cc b/src/cntnfa/operations.cc new file mode 100644 index 000000000..ab60fb7c0 --- /dev/null +++ b/src/cntnfa/operations.cc @@ -0,0 +1,1680 @@ +/* cntnfa-operations.cc -- operations for NFA + */ + +#include +#include +#include + +// MATA headers +#include "mata/cntnfa/annotations.hh" +#include "mata/cntnfa/delta.hh" +#include "mata/utils/sparse-set.hh" +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/algorithms.hh" +#include + +using std::tie; + +using namespace mata::utils; +using namespace mata::cntnfa; +using mata::Symbol; + +using StateBoolArray = std::vector; ///< Bool array for states in the automaton. + +namespace { + Simlib::Util::BinaryRelation compute_fw_direct_simulation(const Cntnfa& aut) { + OrdVector used_symbols = aut.delta.get_used_symbols(); + mata::Symbol unused_symbol = 0; + if (!used_symbols.empty() && *used_symbols.begin() == 0) { + auto it = used_symbols.begin(); + unused_symbol = *it + 1; + ++it; + const auto used_symbols_end = used_symbols.end(); + while (it != used_symbols_end && unused_symbol == *it) { + unused_symbol = *it + 1; + ++it; + } + if (unused_symbol == 0) { // sanity check to see if we did not use the full range of mata::Symbol + throw std::runtime_error("all symbols are used, we cannot compute simulation reduction"); + } + } + + const size_t state_num{ aut.num_of_states() }; + Simlib::ExplicitLTS lts_for_simulation(state_num); + + for (const Transition& transition : aut.delta.transitions()) { + lts_for_simulation.add_transition(transition.source, transition.symbol, transition.target); + } + + // final states cannot be simulated by nonfinal -> we add new selfloops over final states with new symbol in LTS + for (State final_state : aut.final) { + lts_for_simulation.add_transition(final_state, unused_symbol, final_state); + } + + lts_for_simulation.init(); + return lts_for_simulation.compute_simulation(); + } + + Cntnfa reduce_size_by_simulation(const Cntnfa& aut, StateRenaming &state_renaming) { + Cntnfa result; + const auto sim_relation = algorithms::compute_relation( + aut, ParameterMap{{ "relation", "simulation"}, { "direction", "forward"}}); + + auto sim_relation_symmetric = sim_relation; + sim_relation_symmetric.restrict_to_symmetric(); + + // for State q, quot_proj[q] should be the representative state representing the symmetric class of states in simulation + std::vector quot_proj; + sim_relation_symmetric.get_quotient_projection(quot_proj); + + const size_t num_of_states = aut.num_of_states(); + + // map each state q of aut to the state of the reduced automaton representing the simulation class of q + for (State q = 0; q < num_of_states; ++q) { + const State qReprState = quot_proj[q]; + if (state_renaming.count(qReprState) == 0) { // we need to map q's class to a new state in reducedAut + const State qClass = result.add_state(); + state_renaming[qReprState] = qClass; + state_renaming[q] = qClass; + } else { + state_renaming[q] = state_renaming[qReprState]; + } + } + + for (State q = 0; q < num_of_states; ++q) { + const State q_class_state = state_renaming.at(q); + + if (aut.initial[q]) { // if a symmetric class contains initial state, then the whole class should be initial + result.initial.insert(q_class_state); + } + + if (quot_proj[q] == q) { // we process only transitions starting from the representative state, this is enough for simulation + for (const auto &q_trans : aut.delta.state_post(q)) { + const StateSet representatives_of_states_to = [&]{ + StateSet state_set; + for (auto s : q_trans.targets) { + state_set.insert(quot_proj[s]); + } + return state_set; + }(); + + // get the class states of those representatives that are not simulated by another representative in representatives_of_states_to + StateSet representatives_class_states; + for (const State s : representatives_of_states_to) { + bool is_state_important = true; // if true, we need to keep the transition from q to s + for (const State p : representatives_of_states_to) { + if (s != p && sim_relation.get(s, p)) { // if p (different from s) simulates s + is_state_important = false; // as p simulates s, the transition from q to s is not important to keep, as it is subsumed in transition from q to p + break; + } + } + if (is_state_important) { + representatives_class_states.insert(state_renaming.at(s)); + } + } + + // add the transition 'q_class_state-q_trans.symbol->representatives_class_states' at the end of transition list of transitions starting from q_class_state + // as the q_trans.symbol should be the largest symbol we saw (as we iterate trough getTransitionsFromState(q) which is ordered) + result.delta.mutable_state_post(q_class_state).insert(SymbolPost(q_trans.symbol, representatives_class_states)); + } + + if (aut.final[q]) { // if q is final, then all states in its class are final => we make q_class_state final + result.final.insert(q_class_state); + } + } + } + + return result; + } + + void remove_covered_state(const TargetSet& covering_set, const State remove, Cntnfa& nfa) { + TargetSet tmp_targets; // help set to store elements to remove + auto delta_begin = nfa.delta[remove].begin(); + auto remove_size = nfa.delta[remove].size(); + for (size_t i = 0; i < remove_size; i++) { // remove trans from covered state + tmp_targets = delta_begin->targets; + for (const Target target: tmp_targets) { + nfa.delta.remove(remove, delta_begin->symbol, target); + } + } + + auto remove_transitions = nfa.delta.get_transitions_to(remove); + for (const auto& move: remove_transitions) { // transfer transitions from covered state to covering set + for (const Target switch_target: covering_set) { + nfa.delta.add(move.source, move.symbol, switch_target); + } + nfa.delta.remove(move); + } + + // check final and initial states + nfa.final.erase(remove); + if (nfa.initial.contains(remove)) { + nfa.initial.erase(remove); + for (const State new_init: covering_set) { + nfa.initial.insert(new_init); + } + } + } + + void check_covered_and_covering(std::vector& covering_states, // covering sets for each state + std::vector& covering_indexes, // indexes of covering states + std::unordered_map& covered, // map of covered states + std::unordered_map& subset_map, // map of non-covered states + const State Tid, const StateSet& T, // current state to check + Cntnfa& result) { + + auto it = subset_map.begin(); + + // initiate with empty StateSets + covering_states.emplace_back(); + covering_indexes.emplace_back(); + + while (it != subset_map.end()) { // goes through all found states + if (it->first.is_subset_of(T)) { + // check if T is covered + // if so add covering state to its covering StateSet + + covering_states[Tid].insert(it->first); + covering_indexes[Tid].insert(it->second); + } + else if (T.is_subset_of(it->first)) { + // check if state in map is covered + // if so add covering state to its covering StateSet + + covering_states[it->second].insert(T); + covering_indexes[it->second].insert(Tid); + + // check is some already existing state that had a new covering state added turned fully covered + if (it->first == covering_states[it->second]) { + // if any covered state is in the covering set of newly turned covered state, + // then it has to be replaced by its covering set + // + // same applies for any covered state, if it contains newly turned state in theirs + // covering set, then it has to be updated + State erase_state = it->second; // covered state to remove + for (const auto& covered_pair: covered) { + if (covering_indexes[covered_pair.second].contains(erase_state)) { + covering_indexes[covered_pair.second].erase(erase_state); + covering_indexes[covered_pair.second].insert(covering_indexes[erase_state]); + } + if (covering_indexes[erase_state].contains(covered_pair.second)) { + covering_indexes[erase_state].erase(covered_pair.second); + covering_indexes[erase_state].insert(covering_indexes[covered_pair.second]); + } + } + + // remove covered state from the automaton, replace with covering set + remove_covered_state(covering_indexes[erase_state], erase_state, result); + + auto temp = it++; + // move state from subset_map to covered + auto transfer = subset_map.extract(temp); + covered.insert(std::move(transfer)); + continue; // skip increasing map pointer + } + } + ++it; + } + } + + Cntnfa residual_with(const Cntnfa& aut) { // modified algorithm of determinization + + Cntnfa result; + + //assuming all sets targets are non-empty + std::vector> worklist; + std::unordered_map subset_map; + + std::vector covering_states; // check covering set + std::vector covering_indexes; // indexes of covering macrostates + std::unordered_map covered; // map of covered states for transfering new transitions + + result.clear(); + const StateSet S0 = StateSet(aut.initial); + const State S0id = result.add_state(); + result.initial.insert(S0id); + + if (aut.final.intersects_with(S0)) { + result.final.insert(S0id); + } + worklist.emplace_back(S0id, S0); + + (subset_map)[mata::utils::OrdVector(S0)] = S0id; + covering_states.emplace_back(); + covering_indexes.emplace_back(); + + if (aut.delta.empty()){ + return result; + } + + using Iterator = mata::utils::OrdVector::const_iterator; + SynchronizedExistentialSymbolPostIterator synchronized_iterator; + + while (!worklist.empty()) { + const auto Spair = worklist.back(); + worklist.pop_back(); + const StateSet S = Spair.second; + const State Sid = Spair.first; + if (S.empty()) { + // This should not happen assuming all sets targets are non-empty. + break; + } + + // add moves of S to the sync ex iterator + synchronized_iterator.reset(); + for (State q: S) { + mata::utils::push_back(synchronized_iterator, aut.delta[q]); + } + + while (synchronized_iterator.advance()) { + bool add = false; // check whether to add transitions + + // extract post from the sychronized_iterator iterator + const std::vector& moves = synchronized_iterator.get_current(); + Symbol currentSymbol = (*moves.begin())->symbol; + StateSet T = synchronized_iterator.unify_targets(); // new state unify + + auto existingTitr = subset_map.find(T); // check if state was alredy discovered + State Tid; + if (existingTitr != subset_map.end()) { // already visited state + Tid = existingTitr->second; + add = true; + } + else if ((existingTitr = covered.find(T)) != covered.end()) { + Tid = existingTitr->second; + } else { // add new state + Tid = result.add_state(); + check_covered_and_covering(covering_states, covering_indexes, covered, subset_map, Tid, T, result); + + if (T != covering_states[Tid]){ // new state is not covered, replace transitions + subset_map[mata::utils::OrdVector(T)] = Tid; // add to map + + if (aut.final.intersects_with(T)) // add to final + result.final.insert(Tid); + + worklist.emplace_back(Tid, T); + add = true; + + } else { // new state is covered + covered[mata::utils::OrdVector(T)] = Tid; + } + } + + if (covered.find(S) != covered.end()) { + continue; // skip generationg any transitions as the source state was covered right now + } + + if (add) { + result.delta.mutable_state_post(Sid).insert(SymbolPost(currentSymbol, Tid)); + } else { + for (Target switch_target: covering_indexes[Tid]){ + result.delta.add(Sid, currentSymbol, switch_target); + } + } + } + } + + return result; + } + + void residual_recurse_coverable(const std::vector & macrostate_vec, // vector of nfa macrostates + const std::vector & covering_indexes, // sub-vector of macrostates indexes + std::vector & covered, // flags of covered states + std::vector & visited, // flags fo visited states + size_t start_index, // starting index for covering_indexes vec + std::unordered_map *subset_map, // mapping of indexes to macrostates + Cntnfa& nfa) { + + StateSet check_state = macrostate_vec[covering_indexes[start_index]]; + StateSet covering_set; // doesn't contain duplicates + std::vector sub_covering_indexes; // // indexes of covering states + + for (auto i = covering_indexes.begin() + static_cast(start_index+1), e = covering_indexes.end(); i != e; i++) { + if (covered[*i]) // was aready processed + continue; + + if (macrostate_vec[*i].is_subset_of(check_state)) { + covering_set.insert(macrostate_vec[*i]); // is never covered + sub_covering_indexes.push_back(*i); + } + } + + if (covering_set == check_state) { // can recurse even without covered :thinking: + + size_t covering_size = sub_covering_indexes.size()-1; + for (size_t k = 0; k < covering_size; k++) { + if (macrostate_vec[sub_covering_indexes[k]].size() == 1) // end on single-sized states + break; + + if (visited[sub_covering_indexes[k]]) // already processed + continue; + + visited[sub_covering_indexes[k]] = true; + + residual_recurse_coverable(macrostate_vec, sub_covering_indexes, covered, visited, k, subset_map, nfa); + } + + covering_set.clear(); // clear variable to store only needed macrostates + for (auto index : sub_covering_indexes) { + if (covered[index] == 0) { + auto macrostate_ptr = subset_map->find(macrostate_vec[index]); + if (macrostate_ptr == subset_map->end()) // should never happen + throw std::runtime_error(std::to_string(__func__) + " couldn't find expected element in a map."); + + covering_set.insert(macrostate_ptr->second); + } + } + + remove_covered_state(covering_set, subset_map->find(check_state)->second, nfa); + covered[covering_indexes[start_index]] = true; + } + + + } + + Cntnfa residual_after(const Cntnfa& aut) { + std::unordered_map subset_map{}; + Cntnfa result; + result = determinize(aut, &subset_map); + + std::vector macrostate_vec; // ordered vector of macrostates + macrostate_vec.reserve(subset_map.size()); + for (const auto& pair: subset_map) { // order by size from largest to smallest + macrostate_vec.insert(std::upper_bound(macrostate_vec.begin(), macrostate_vec.end(), pair.first, + [](const StateSet & a, const StateSet & b){ return a.size() > b.size(); }), pair.first); + } + + std::vector covered(subset_map.size(), false); // flag of covered states, removed from nfa + std::vector visited(subset_map.size(), false); // flag of processed state + + StateSet covering_set; // doesn't contain duplicates + std::vector covering_indexes; // indexes of covering states + size_t macrostate_size = macrostate_vec.size(); + for (size_t i = 0; i < macrostate_size-1; i++) { + if (macrostate_vec[i].size() == 1) // end searching on single-sized macrostates + break; + + if (visited[i]) // was already processed + continue; + + covering_set.clear(); + covering_indexes.clear(); + visited[i] = true; + + for (size_t j = i+1; j < macrostate_size; j++) { // find covering macrostates + if (covered[j]) // if covered there are smaller macrostates, skip + continue; + + if (macrostate_vec[j].is_subset_of(macrostate_vec[i])) { // found covering state + covering_set.insert(macrostate_vec[j]); // is not covered + covering_indexes.push_back(j); + } + } + + if (covering_set == macrostate_vec[i]) { + size_t covering_size = covering_indexes.size()-1; + for (size_t k = 0; k < covering_size; k++) { // check resurse coverability + if (macrostate_vec[covering_indexes[k]].size() == 1) // end on single-sized + break; + + if (visited[covering_indexes[k]]) // already processed + continue; + + visited[covering_indexes[k]] = true; + + residual_recurse_coverable(macrostate_vec, covering_indexes, covered, visited, k, &subset_map, result); + } + + covering_set.clear(); // clear variable to store only needed macrostates + for (auto index : covering_indexes) { + if (covered[index] == 0) { + auto macrostate_ptr = subset_map.find(macrostate_vec[index]); + if (macrostate_ptr == subset_map.end()) // should never happen + throw std::runtime_error(std::to_string(__func__) + " couldn't find expected element in a map."); + + covering_set.insert(macrostate_ptr->second); + } + } + + remove_covered_state(covering_set, subset_map.find(macrostate_vec[i])->second, result); + covered[i] = true; + } + } + + return result; + } + + Cntnfa reduce_size_by_residual(const Cntnfa& aut, StateRenaming &state_renaming, const std::string& type, const std::string& direction){ + Cntnfa back_determinized = aut; + Cntnfa result; + + if (direction != "forward" && direction != "backward"){ + throw std::runtime_error(std::to_string(__func__) + + " received an unknown value of the \"direction\" key: " + direction); + } + + // forward canonical residual automaton is firstly backward determinized and + // then the residual construction is done forward, for backward residual automaton + // is it the opposite, so the automaton is reverted once more before and after + // construction, however the first two reversion negate each other out + if (direction == "forward") + back_determinized = revert(back_determinized); + back_determinized = revert(determinize(back_determinized)); // backward deteminization + + // not relly sure how to handle state_renaming + (void) state_renaming; + + // two different implementations of the same algorithm, for type "after" the + // residual automaton and removal of covering states is done after the final + // determinization if finished, for type "with" this residual construction is + // done during the last determinization, both types had similar results in + // effectivity, their output is almost the same expect the transitions, those + // may slightly differ, but number of states is the same for both types + if (type == "with") { + result = residual_with(back_determinized); + } + else if (type == "after") { + result = residual_after(back_determinized); + } else { + throw std::runtime_error(std::to_string(__func__) + + " received an unknown value of the \"type\" key: " + type); + } + + if (direction == "backward") + result = revert(result); + + return result.trim(); + } +} + +std::ostream &std::operator<<(std::ostream &os, const mata::cntnfa::Transition &trans) { // {{{ + std::string result = "(" + std::to_string(trans.source) + ", " + + std::to_string(trans.symbol) + ", " + std::to_string(trans.target) + ")"; + return os << result; +} + +bool mata::cntnfa::Cntnfa::make_complete(const Alphabet* const alphabet, const std::optional sink_state) { + return make_complete(get_symbols_to_work_with(*this, alphabet), sink_state); +} + +bool mata::cntnfa::Cntnfa::make_complete(const OrdVector& symbols, const std::optional sink_state) { + bool transition_added{ false }; + const size_t num_of_states{ this->num_of_states() }; + const Target sink_state_val{ sink_state.value_or(num_of_states) }; + + OrdVector used_symbols{}; + for (State state{ 0 }; state < num_of_states; ++state) { + for (const SymbolPost& symbol_post: delta[state]) { + used_symbols.insert(symbol_post.symbol); + } + const OrdVector unused_symbols{ symbols.difference(used_symbols) }; + for (const Symbol symbol: unused_symbols) { + delta.add(state, symbol, sink_state_val); + transition_added = true; + } + used_symbols.clear(); + } + + if (transition_added && num_of_states <= sink_state_val) { + for (const Symbol symbol: symbols) { + delta.add(sink_state_val, symbol, sink_state_val); + } + } + + return transition_added; +} + +//TODO: based on the comments inside, this function needs to be rewritten in a more optimal way. +Cntnfa mata::cntnfa::remove_epsilon(const Cntnfa& aut, Symbol epsilon) { + // cannot use multimap, because it can contain multiple occurrences of (a -> a), (a -> a) + std::unordered_map eps_closure; + + // TODO: grossly inefficient + // first we compute the epsilon closure + const size_t num_of_states{aut.num_of_states() }; + for (size_t i{ 0 }; i < num_of_states; ++i) + { + for (const auto& trans: aut.delta[i]) + { // initialize + const auto it_ins_pair = eps_closure.insert({i, {i}}); + if (trans.symbol == epsilon) + { + StateSet& closure = it_ins_pair.first->second; + // TODO: Fix possibly insert to OrdVector. Create list already ordered, then merge (do not need to resize each time); + closure.insert(trans.targets); + } + } + } + + bool changed = true; + while (changed) { // Compute the fixpoint. + changed = false; + for (size_t i = 0; i < num_of_states; ++i) { + const StatePost& post{ aut.delta[i] }; + const auto eps_move_it { post.find(epsilon) };//TODO: make faster if default epsilon + if (eps_move_it != post.end()) { + StateSet& src_eps_cl = eps_closure[i]; + for (const State tgt: eps_move_it->targets) { + const StateSet& tgt_eps_cl = eps_closure[tgt]; + for (const State st: tgt_eps_cl) { + if (src_eps_cl.count(st) == 0) { + changed = true; + break; + } + } + src_eps_cl.insert(tgt_eps_cl); + } + } + } + } + + // Construct the automaton without epsilon transitions. + Cntnfa result{ Delta{}, aut.initial, aut.final, + AnnotationCollection{}, CounterSet{}, + aut.alphabet }; + for (const auto& state_closure_pair : eps_closure) { // For every state. + State src_state = state_closure_pair.first; + for (State eps_cl_state : state_closure_pair.second) { // For every state in its epsilon closure. + if (aut.final[eps_cl_state]) result.final.insert(src_state); + for (const SymbolPost& move : aut.delta[eps_cl_state]) { + if (move.symbol == epsilon) continue; + // TODO: this could be done more efficiently if we had a better add method + for (Target tgt_state : move.targets) { + result.delta.add(src_state, move.symbol, tgt_state); + } + } + } + } + return result; +} + +Cntnfa mata::cntnfa::fragile_revert(const Cntnfa& aut) { + const size_t num_of_states{ aut.num_of_states() }; + + Cntnfa result(num_of_states); + + result.initial = aut.final; + result.final = aut.initial; + + // Compute non-epsilon symbols. + OrdVector symbols = aut.delta.get_used_symbols(); + if (symbols.empty()) { return result; } + if (symbols.back() == EPSILON) { symbols.pop_back(); } + // size of the "used alphabet", i.e. max symbol+1 or 0 + Symbol alphasize = (symbols.empty()) ? 0 : (symbols.back()+1); + +#ifdef _STATIC_STRUCTURES_ + //STATIC DATA STRUCTURES: + // Not sure that it works ideally, whether the space for the inner vectors stays there. + static std::vector> sources; + static std::vector> targets; + static std::vector e_sources; + static std::vector e_targets; + if (alphasize>sources.size()) { + sources.resize(alphasize); + targets.resize(alphasize); + } + + e_sources.clear(); + e_targets.clear(); + + //WHEN ONLY MAX SYMBOL IS COMPUTED + // for (int i = 0;i> sources (alphasize); + std::vector> targets (alphasize); + std::vector e_sources; + std::vector e_targets; +#endif + + //Copy all transition with non-e symbols to the arrays of sources and targets indexed by symbols. + //Targets and sources of e-transitions go to the special place. + //Important: since we are going through delta in order of sources, the sources arrays are all ordered. + for (State sourceState{ 0 }; sourceState < num_of_states; ++sourceState) { + for (const SymbolPost &move: aut.delta[sourceState]) { + if (move.symbol == EPSILON) { + for (const State targetState: move.targets) { + //reserve_on_insert(e_sources); + e_sources.push_back(sourceState); + //reserve_on_insert(e_targets); + e_targets.push_back(targetState); + } + } + else { + for (const State targetState: move.targets) { + //reserve_on_insert(sources[move.symbol]); + sources[move.symbol].push_back(sourceState); + //reserve_on_insert(targets[move.symbol]); + targets[move.symbol].push_back(targetState); + } + } + } + } + + //Now make the delta of the reversed automaton. + //Important: since sources are ordered, when adding them as targets, we can just push them back. + result.delta.reserve(num_of_states); + + // adding non-e transitions + for (const Symbol symbol: symbols) { + for (size_t i{ 0 }; i < sources[symbol].size(); ++i) { + State tgt_state =sources[symbol][i]; + State src_state =targets[symbol][i]; + StatePost & src_post = result.delta.mutable_state_post(src_state); + if (src_post.empty() || src_post.back().symbol != symbol) { + src_post.push_back(SymbolPost(symbol)); + } + src_post.back().push_back(tgt_state); + } + } + + // adding e-transitions + for (size_t i{ 0 }; i < e_sources.size(); ++i) { + State tgt_state =e_sources[i]; + State src_state =e_targets[i]; + StatePost & src_post = result.delta.mutable_state_post(src_state); + if (src_post.empty() || src_post.back().symbol != EPSILON) { + src_post.push_back(SymbolPost(EPSILON)); + } + src_post.back().push_back(tgt_state); + } + + //sorting the targets + //Hm I don't know why I put this here, but it should not be needed ... + //for (State q = 0, states_num = result.delta.post_size(); qtargets); + // } + //} + + return result; +} + +Cntnfa mata::cntnfa::simple_revert(const Cntnfa& aut) { + Cntnfa result; + result.clear(); + + const size_t num_of_states{ aut.num_of_states() }; + result.delta.allocate(num_of_states); + + for (Target sourceState{ 0 }; sourceState < num_of_states; ++sourceState) { + for (const SymbolPost &transition: aut.delta[sourceState]) { + for (const Target targetState: transition.targets) { + result.delta.add(targetState, transition.symbol, sourceState); + } + } + } + + result.initial = aut.final; + result.final = aut.initial; + + return result; +} + +//not so great, can be removed +Cntnfa mata::cntnfa::somewhat_simple_revert(const Cntnfa& aut) { + const size_t num_of_states{ aut.num_of_states() }; + + Cntnfa result(num_of_states); + + result.initial = aut.final; + result.final = aut.initial; + + for (State sourceState{ 0 }; sourceState < num_of_states; ++sourceState) { + for (const SymbolPost &transition: aut.delta[sourceState]) { + for (const State targetState: transition.targets) { + StatePost & post = result.delta.mutable_state_post(targetState); + //auto move = std::find(post.begin(),post.end(),Move(transition.symbol)); + auto move = post.find(SymbolPost(transition.symbol)); + if (move == post.end()) { + //post.push_back(Move(transition.symbol,sourceState)); + post.insert(SymbolPost(transition.symbol, sourceState)); + } + else + move->push_back(sourceState); + //move->insert(sourceState); + } + } + } + + //sorting the targets + for (State q = 0, states_num = result.delta.num_of_states(); q < states_num; ++q) { + //Post & post = result.delta.get_mutable_post(q); + //utils::sort_and_rmdupl(post); + for (SymbolPost& m: result.delta.mutable_state_post(q)) { sort_and_rmdupl(m.targets); } + } + + return result; +} + +Cntnfa mata::cntnfa::revert(const Cntnfa& aut) { + return simple_revert(aut); + //return fragile_revert(aut); + //return somewhat_simple_revert(aut); +} + +bool mata::cntnfa::Cntnfa::is_deterministic() const { + if (initial.size() != 1) { return false; } + + if (delta.empty()) { return true; } + + const size_t aut_size = num_of_states(); + for (size_t i = 0; i < aut_size; ++i) { + for (const auto& symStates : delta[i]) { + if (symStates.num_of_targets() != 1) { return false; } + } + } + + return true; +} +bool mata::cntnfa::Cntnfa::is_complete(Alphabet const* alphabet) const { + utils::OrdVector symbols{ get_symbols_to_work_with(*this, alphabet) }; + utils::OrdVector symbs_ls{ symbols }; + + // TODO: make a general function for traversal over reachable states that can be shared by other functions? + std::list worklist(initial.begin(), initial.end()); + std::unordered_set processed(initial.begin(), initial.end()); + + while (!worklist.empty()) { + State state = *worklist.begin(); + worklist.pop_front(); + + size_t n = 0; // counter of symbols + if (!delta.empty()) { + for (const auto &symb_stateset: delta[state]) { + ++n; + if (!haskey(symbols, symb_stateset.symbol)) { + throw std::runtime_error(std::to_string(__func__) + + ": encountered a symbol that is not in the provided alphabet"); + } + + for (const auto &tgt_state: symb_stateset.targets) { + bool inserted; + tie(std::ignore, inserted) = processed.insert(tgt_state); + if (inserted) { worklist.push_back(tgt_state); } + } + } + } + + if (symbols.size() != n) { return false; } + } + + return true; +} + +std::pair mata::cntnfa::Cntnfa::get_word_for_path(const Run& run) const { + if (run.path.empty()) { return {{}, true}; } + + Run word; + State cur = run.path[0]; + for (size_t i = 1; i < run.path.size(); ++i) { + State newSt = run.path[i]; + bool found = false; + if (!this->delta.empty()) { + for (const auto &symbolMap: this->delta[cur]) { + for (State st: symbolMap.targets) { + if (st == newSt) { + word.word.push_back(symbolMap.symbol); + found = true; + break; + } + } + if (found) { break; } + } + } + if (!found) { return {{}, false}; } + cur = newSt; // update current state + } + return {word, true}; +} + +// TODO: this behavior is correct? it can be chaged (generic counter automaton) +bool mata::cntnfa::Cntnfa::is_in_lang_of_counter_nfa(const Run& run) const { + std::vector configs; + + // For each initial state, create a configuration that includes the current counter set state + for (State s : this->initial) { + configs.push_back(Configuration{ s, this->counter_set.copy() }); + } + + // Process each symbol in the input word one-by-one + for (const Symbol sym : run.word) { + std::vector next_configs; + + // For each configuration, check the transitions for the current symbol + for (const auto& cfg : configs) { + // Look up possible transitions from the current state + const StatePost& post = this->delta[cfg.state]; + + // Find the transitions that match the current symbol + auto symbol_it = post.find(sym); + if (symbol_it == post.end()) { + continue; + } + + // For every transition target reachable via this symbol + for (const auto& tgt : symbol_it->targets) { + // Copy the current configuration + Configuration next_cfg = cfg; + next_cfg.registers = cfg.registers.copy(); + + // Update the state to the target state + next_cfg.state = tgt.state; + + // If the transition has annotations (counter operations or checks) + if (tgt.annotations_id != UNDEFINED_ANNOTATIONS) { + const auto& anns = this->annotation_collection[tgt.annotations_id]; + + // Check if all annotations pass + bool passed = true; + + // Perform the annotation guard + for (const auto& ann : anns) { + passed &= ann->guard(next_cfg.registers); + if (!passed) break; + } + + // Skip this transition if any guard fails + if (!passed) { + continue; + } + + // Perform the annotation update + for (const auto& ann : anns) { + ann->update(next_cfg.registers); + } + } + + // Add the new configuration if annotations passed + next_configs.push_back(std::move(next_cfg)); + } + } + + // No successful transitions + if (next_configs.empty()) { + return false; + } + + // Move to the next set of configurations + configs = std::move(next_configs); + } + + // After processing all symbols, check if any of the configurations end in a final state + for (const auto& cfg : configs) { + if (this->final.contains(cfg.state)) { + return true; + } + } + + // No configuration reached a final state, reject the run + return false; +} + +//TODO: this is not efficient +bool mata::cntnfa::Cntnfa::is_in_lang(const Run& run) const { + StateSet current_post(this->initial); + for (const Symbol sym : run.word) { + current_post = this->post(current_post, sym); + if (current_post.empty()) { return false; } + } + return this->final.intersects_with(current_post); +} + +/// Checks whether the prefix of a string is in the language of an automaton +// TODO: slow and it should share code with is_in_lang +bool mata::cntnfa::Cntnfa::is_prfx_in_lang(const Run& run) const { + StateSet current_post{ this->initial }; + for (const Symbol sym : run.word) { + if (this->final.intersects_with(current_post)) { return true; } + current_post = this->post(current_post, sym); + if (current_post.empty()) { return false; } + } + return this->final.intersects_with(current_post); +} + +// FIXME: This function is not working correctly. +bool mata::cntnfa::Cntnfa::is_counter_nfa_lang_empty(Run* cex) const { + using Config = Configuration; + + // Custom hasher for configuration (state + counter values) + struct ConfigHasher { + std::size_t operator()(const Config& cfg) const { + std::size_t seed = std::hash()(cfg.state); + for (size_t i = 0; i < cfg.registers.size(); ++i) { + seed ^= std::hash()(cfg.registers.get(i)) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + } + return seed; + } + }; + + std::list worklist; // queue of configurations to explore + std::unordered_set processed; // visited configurations + std::unordered_map predecessors; // for path reconstruction + std::unordered_map incoming_symbol; // transitions used + + // Start from initial states with zero-initialized counters + for (State s : initial) { + Config init_cfg{s, counter_set}; + worklist.push_back(init_cfg); + processed.insert(init_cfg); + predecessors[init_cfg] = init_cfg; + } + + // BFS-style traversal over configurations + while (!worklist.empty()) { + Config cfg = worklist.front(); + worklist.pop_front(); + + // If current state is final, we've found a word in the language + if (final.contains(cfg.state)) { + if (cex) { + Run path; + Config current = cfg; + + while (predecessors[current].state != current.state) { + path.path.push_back(current.state); + path.word.push_back(incoming_symbol[current]); + current = predecessors[current]; + } + + path.path.push_back(current.state); + std::reverse(path.path.begin(), path.path.end()); + std::reverse(path.word.begin(), path.word.end()); + *cex = std::move(path); + } + + // Language is not empty + return false; + } + + // Explore all transitions from current state + for (const auto& [symbol, post] : delta[cfg.state]) { + for (const auto& tgt : post) { + Config next_cfg = cfg; + next_cfg.state = tgt.state; + + // Apply annotations in correct order: + // 1. Assignments/Increments: modify counter values + // 2. Tests: validate if the transition is allowed + + bool passed = true; + + if (tgt.annotations_id != UNDEFINED_ANNOTATIONS) { + const auto& anns = annotation_collection[tgt.annotations_id]; + + // Apply counter updates + for (const auto& ann : anns) { + AnnotationType type = ann->get_type(); + if (type == AnnotationType::CounterAssign || + type == AnnotationType::CounterIncrement) + { + ann->update(next_cfg.registers); + } + } + + // Check counter guards + for (const auto& ann : anns) { + AnnotationType type = ann->get_type(); + if (type == AnnotationType::CounterEqual || + type == AnnotationType::CounterGreater || + type == AnnotationType::CounterLess) + { + if (!ann->guard(next_cfg.registers)) { + passed = false; + break; + } + } + } + } + + if (!passed) { + // Skip invalid transitions + continue; + } + + // If this configuration was not visited yet, enqueue it + if (!processed.contains(next_cfg)) { + worklist.push_back(next_cfg); + processed.insert(next_cfg); + predecessors[next_cfg] = cfg; + incoming_symbol[next_cfg] = symbol; + } + } + } + } + + // No accepting run found, language is empty + return true; +} // is_counter_nfa_lang_empty(). + +bool mata::cntnfa::Cntnfa::is_lang_empty(Run* cex) const { + // TODO: hot fix for performance reasons for TACAS. + // Perhaps make the get_useful_states return a witness on demand somehow. + if (!cex) { + return is_lang_empty_scc(); + } + + std::list worklist(initial.begin(), initial.end()); + std::unordered_set processed(initial.begin(), initial.end()); + + // 'paths[s] == t' denotes that state 's' was accessed from state 't', + // 'paths[s] == s' means that 's' is an initial state + std::map paths; + // Initialize paths. + for (const State s: worklist) { paths[s] = s; } + + State state; + while (!worklist.empty()) { + state = worklist.front(); + worklist.pop_front(); + + if (final[state]) { + if (nullptr != cex) { + cex->path.clear(); + cex->path.push_back(state); + while (paths[state] != state) { + state = paths[state]; + cex->path.push_back(state); + } + std::reverse(cex->path.begin(), cex->path.end()); + cex->word = this->get_word_for_path(*cex).first.word; + } + return false; + } + + if (delta.empty()) { continue; } + + for (const SymbolPost& symbol_post: delta[state]) { + for (const auto& target: symbol_post.targets) { + bool inserted; + tie(std::ignore, inserted) = processed.insert(target); + if (inserted) { + worklist.push_back(target); + // Also set that tgt_state was accessed from state. + paths[target] = state; + } else { assert(haskey(paths, target)); /* Invariant. */ } + } + } + } // while (!worklist.empty()). + return true; +} // is_lang_empty(). + + +Cntnfa mata::cntnfa::algorithms::minimize_brzozowski(const Cntnfa& aut) { + //compute the minimal deterministic automaton, Brzozovski algorithm + return determinize(revert(determinize(revert(aut)))); +} + +Cntnfa mata::cntnfa::minimize( + const Cntnfa& aut, + const ParameterMap& params) +{ + Cntnfa result; + // setting the default algorithm + decltype(algorithms::minimize_brzozowski)* algo = algorithms::minimize_brzozowski; + if (!haskey(params, "algorithm")) { + throw std::runtime_error(std::to_string(__func__) + + " requires setting the \"algo\" key in the \"params\" argument; " + "received: " + std::to_string(params)); + } + + const std::string& str_algo = params.at("algorithm"); + if ("brzozowski" == str_algo) { /* default */ } + else { + throw std::runtime_error(std::to_string(__func__) + + " received an unknown value of the \"algo\" key: " + str_algo); + } + + return algo(aut); +} + +Cntnfa mata::cntnfa::intersection_counter_nfas(const Cntnfa &lhs, const Cntnfa &rhs) { + return algorithms::product_counter_nfas(lhs, rhs); +} + +Cntnfa mata::cntnfa::intersection(const Cntnfa& lhs, const Cntnfa& rhs, const Symbol first_epsilon, std::unordered_map, State> *prod_map) { // udelat override TODO + + auto both_final = [&](const State lhs_state,const State rhs_state) { + return lhs.final.contains(lhs_state) && rhs.final.contains(rhs_state); + }; + + if (lhs.final.empty() || lhs.initial.empty() || rhs.initial.empty() || rhs.final.empty()) + return Cntnfa{}; + + return algorithms::product(lhs, rhs, both_final, first_epsilon, prod_map); +} + +Cntnfa mata::cntnfa::union_product(const Cntnfa &lhs, const Cntnfa &rhs, const Symbol first_epsilon, std::unordered_map,State> *prod_map) { + auto one_final = [&](const State lhs_state,const State rhs_state) { + return lhs.final.contains(lhs_state) || rhs.final.contains(rhs_state); + }; + + if (lhs.final.empty() || lhs.initial.empty()) { return rhs; } + if (rhs.final.empty() || rhs.initial.empty()) { return lhs; } + return algorithms::product(lhs, rhs, one_final, first_epsilon, prod_map); +} + +// TODO: Do we need this function? It can be useful if we want counters to be shared. +Cntnfa mata::cntnfa::union_nondet_counter_nfas(const Cntnfa &lhs, const Cntnfa &rhs) { + return Cntnfa{lhs}.unite_nondet_counter_nfa_with(rhs); +} + +Cntnfa mata::cntnfa::union_nondet(const Cntnfa &lhs, const Cntnfa &rhs) { + return Cntnfa{lhs}.unite_nondet_with(rhs); +} + +Simlib::Util::BinaryRelation mata::cntnfa::algorithms::compute_relation(const Cntnfa& aut, const ParameterMap& params) { + if (!haskey(params, "relation")) { + throw std::runtime_error(std::to_string(__func__) + + " requires setting the \"relation\" key in the \"params\" argument; " + "received: " + std::to_string(params)); + } + if (!haskey(params, "direction")) { + throw std::runtime_error(std::to_string(__func__) + + " requires setting the \"direction\" key in the \"params\" argument; " + "received: " + std::to_string(params)); + } + + const std::string& relation = params.at("relation"); + const std::string& direction = params.at("direction"); + if ("simulation" == relation && direction == "forward") { + return compute_fw_direct_simulation(aut); + } + else { + throw std::runtime_error(std::to_string(__func__) + + " received an unknown value of the \"relation\" key: " + relation); + } +} + +Cntnfa mata::cntnfa::reduce(const Cntnfa &aut, StateRenaming *state_renaming, const ParameterMap& params) { + if (!haskey(params, "algorithm")) { + throw std::runtime_error(std::to_string(__func__) + + " requires setting the \"algorithm\" key in the \"params\" argument; " + "received: " + std::to_string(params)); + } + + Cntnfa result; + std::unordered_map reduced_state_map; + const std::string& algorithm = params.at("algorithm"); + if ("simulation" == algorithm) { + result = reduce_size_by_simulation(aut, reduced_state_map); + } + else if ("residual" == algorithm) { + // reduce type either 'after' or 'with' creation of residual automaton + if (!haskey(params, "type")) { + throw std::runtime_error(std::to_string(__func__) + + " requires setting the \"type\" key in the \"params\" argument; " + "received: " + std::to_string(params)); + } + // forward or backward canonical residual automaton + if (!haskey(params, "direction")) { + throw std::runtime_error(std::to_string(__func__) + + " requires setting the \"direction\" key in the \"params\" argument; " + "received: " + std::to_string(params)); + } + + const std::string& residual_type = params.at("type"); + const std::string& residual_direction = params.at("direction"); + + result = reduce_size_by_residual(aut, reduced_state_map, residual_type, residual_direction); + } else { + throw std::runtime_error(std::to_string(__func__) + + " received an unknown value of the \"algorithm\" key: " + algorithm); + } + + if (state_renaming) { + state_renaming->clear(); + *state_renaming = reduced_state_map; + } + return result; +} + +Cntnfa mata::cntnfa::determinize( + const Cntnfa& aut, std::unordered_map* subset_map, + std::optional> macrostate_discover +) { + Cntnfa result{}; + //assuming all sets targets are non-empty + std::vector> worklist{}; + std::unordered_map subset_map_local{}; + if (subset_map == nullptr) { subset_map = &subset_map_local; } + + const StateSet S0{ aut.initial }; + const State S0id{ result.add_state() }; + result.initial.insert(S0id); + + if (aut.final.intersects_with(S0)) { + result.final.insert(S0id); + } + worklist.emplace_back(S0id, S0); + (*subset_map)[mata::utils::OrdVector(S0)] = S0id; + if (aut.delta.empty()) { return result; } + if (macrostate_discover.has_value() && !(*macrostate_discover)(result, S0id, S0)) { return result; } + + using Iterator = mata::utils::OrdVector::const_iterator; + SynchronizedExistentialSymbolPostIterator synchronized_iterator; + + while (!worklist.empty()) { + const auto Spair = worklist.back(); + worklist.pop_back(); + const StateSet S = Spair.second; + const State Sid = Spair.first; + if (S.empty()) { + // This should not happen assuming all sets targets are non-empty. + break; + } + + // add moves of S to the sync ex iterator + synchronized_iterator.reset(); + for (State q: S) { + mata::utils::push_back(synchronized_iterator, aut.delta[q]); + } + + while (synchronized_iterator.advance()) { + // extract post from the synchronized_iterator iterator + const std::vector& symbol_posts = synchronized_iterator.get_current(); + Symbol currentSymbol = (*symbol_posts.begin())->symbol; + StateSet T = synchronized_iterator.unify_targets(); + + const auto existingTitr = subset_map->find(T); + State Tid; + if (existingTitr != subset_map->end()) { + Tid = existingTitr->second; + } else { + Tid = result.add_state(); + (*subset_map)[mata::utils::OrdVector(T)] = Tid; + if (aut.final.intersects_with(T)) { + result.final.insert(Tid); + } + worklist.emplace_back(Tid, T); + } + result.delta.mutable_state_post(Sid).insert(SymbolPost(currentSymbol, Tid)); + if (macrostate_discover.has_value() && existingTitr == subset_map->end() + && !(*macrostate_discover)(result, Tid, T)) { return result; } + } + } + return result; +} + +std::ostream& std::operator<<(std::ostream& os, const Cntnfa& nfa) { + nfa.print_to_mata(os); + return os; +} + +void mata::cntnfa::Cntnfa::fill_alphabet(OnTheFlyAlphabet& alphabet_to_fill) const { + for (const StatePost& state_post: this->delta) { + for (const SymbolPost& symbol_post: state_post) { + alphabet_to_fill.update_next_symbol_value(symbol_post.symbol); + alphabet_to_fill.try_add_new_symbol(std::to_string(symbol_post.symbol), symbol_post.symbol); + } + } +} + +mata::OnTheFlyAlphabet mata::cntnfa::create_alphabet(const std::vector>& nfas) { + mata::OnTheFlyAlphabet alphabet{}; + for (const auto& nfa: nfas) { + nfa.get().fill_alphabet(alphabet); + } + return alphabet; +} + +mata::OnTheFlyAlphabet mata::cntnfa::create_alphabet(const std::vector>& nfas) { + mata::OnTheFlyAlphabet alphabet{}; + for (const auto& nfa: nfas) { + nfa.get().fill_alphabet(alphabet); + } + return alphabet; +} + +mata::OnTheFlyAlphabet mata::cntnfa::create_alphabet(const std::vector& nfas) { + mata::OnTheFlyAlphabet alphabet{}; + for (const Cntnfa* const nfa: nfas) { + nfa->fill_alphabet(alphabet); + } + return alphabet; +} + +mata::OnTheFlyAlphabet mata::cntnfa::create_alphabet(const std::vector& nfas) { + mata::OnTheFlyAlphabet alphabet{}; + for (const Cntnfa* const nfa: nfas) { + nfa->fill_alphabet(alphabet); + } + return alphabet; +} + +Run mata::cntnfa::encode_word(const Alphabet* alphabet, const std::vector& input) { + return { .word = alphabet->translate_word(input) }; +} + +std::set mata::cntnfa::Cntnfa::get_words(unsigned max_length) const { + std::set result; + + // contains a pair: a state s and the word with which we got to the state s + std::vector> worklist; + // initializing worklist + for (State init_state : initial) { + worklist.push_back({init_state, {}}); + if (final.contains(init_state)) { + result.insert(mata::Word()); + } + } + + // will be used during the loop + std::vector> new_worklist; + + unsigned cur_length = 0; + while (!worklist.empty() && cur_length < max_length) { + new_worklist.clear(); + for (const auto& state_and_word : worklist) { + State s_from = state_and_word.first; + const mata::Word& word = state_and_word.second; + for (const SymbolPost& sp : delta[s_from]) { + mata::Word new_word = word; + new_word.push_back(sp.symbol); + for (State s_to : sp.targets) { + new_worklist.emplace_back(s_to, new_word); + if (final.contains(s_to)) { + result.insert(new_word); + } + } + } + } + worklist.swap(new_worklist); + ++cur_length; + } + + return result; +} + +OrdVector mata::cntnfa::get_symbols_to_work_with(const Cntnfa& nfa, const mata::Alphabet *const shared_alphabet) { + if (shared_alphabet != nullptr) { return shared_alphabet->get_alphabet_symbols(); } + else if (nfa.alphabet != nullptr) { return nfa.alphabet->get_alphabet_symbols(); } + else { return nfa.delta.get_used_symbols(); } +} + +std::optional Cntnfa::get_word(const Symbol first_epsilon) const { + if (initial.empty() || final.empty()) { return std::nullopt; } + if (initial.intersects_with(final)) { return Word{}; } + + /// Current state state post iterator, its end iterator, and iterator in the current symbol post to target states. + /// Note: Changed targets_it StateSet::const_iterator to TargetSet::const_iterator. + std::vector> worklist{}; + std::vector searched(num_of_states(), false); + bool final_found{}; + for (const State initial_state: initial) { + if (searched[initial_state]) { continue; } + searched[initial_state] = true; + + const StatePost& initial_state_post{ delta[initial_state] }; + auto initial_symbol_post_it{ initial_state_post.cbegin() }; + auto initial_symbol_post_end{ initial_state_post.cend() }; + // Initialize the worklist for the given @p initial_state with the first valid transition. + while (worklist.empty() && initial_symbol_post_it != initial_state_post.cend()) { + auto initial_target_it{ initial_symbol_post_it->targets.cbegin() }; + do { + if (searched[*initial_target_it]) { + ++initial_target_it; + } else { + worklist.emplace_back(initial_symbol_post_it, initial_symbol_post_end, initial_target_it); + break; + } + } while (initial_target_it != initial_symbol_post_it->targets.cend()); + if (initial_target_it == initial_symbol_post_it->targets.cend()) { + ++initial_symbol_post_it; + } + } + + // Try to recursively walk through the NFA transitions from the current @p initial_state until a final state is + // encountered or all states reachable from @p initial_state are searched without finding any final state. + while (!worklist.empty()) { + // Using references to iterators to be able to increment the top-most element in the worklist in place. + auto& [state_post_it, state_post_end, targets_it]{ worklist.back() }; + if (state_post_it != state_post_end) { + if (targets_it != state_post_it->targets.cend()) { + if (searched[*targets_it]) { ++targets_it; continue; } + if (final.contains(*targets_it)) { final_found = true; break; } + searched[*targets_it] = true; + const StatePost& state_post{ delta[*targets_it] }; + if (!state_post.empty()) { + auto new_state_post_it{ state_post.cbegin() }; + auto new_targets_it{ new_state_post_it->cbegin() }; + worklist.emplace_back(new_state_post_it, state_post.cend(), new_targets_it); + } else { ++targets_it; } + } else { // targets_it == state_post_it->targets.cend(). + ++state_post_it; + if (state_post_it != state_post_end) { targets_it = state_post_it->cbegin(); } + } + } else { // state_post_it == state_post_end. + worklist.pop_back(); + auto& [_prev_state_post_it, _prev_state_post_end, prev_targets_it]{ worklist.back() }; + ++prev_targets_it; + } + } + if (final_found) { break; } + } + + if (!final_found) { return std::nullopt; } + Word word; + word.reserve(worklist.size()); + for (const auto& [symbol_post_it, symbol_post_end, _targets_it]: worklist) { + if (symbol_post_it->symbol < first_epsilon) { word.push_back(symbol_post_it->symbol); } + } + return word; +} + +std::optional Cntnfa::get_word_from_complement(const Alphabet* alphabet) const { + if (are_disjoint(initial, final)) { return Word{}; } + + std::vector::const_pointer> worklist{}; + std::unordered_map subset_map{}; + + Cntnfa nfa_complete{}; + const Target sink_state{ nfa_complete.add_state() }; + nfa_complete.final.insert(sink_state); + const State new_initial{ nfa_complete.add_state() }; + nfa_complete.initial.insert(new_initial); + auto subset_map_it{ subset_map.emplace(initial, new_initial).first }; + worklist.emplace_back(subset_map_it.operator->()); + + using Iterator = mata::utils::OrdVector::const_iterator; + SynchronizedExistentialSymbolPostIterator synchronized_iterator{}; + + const utils::OrdVector symbols{ get_symbols_to_work_with(*this, alphabet) }; + const auto symbols_end{ symbols.end() }; + bool continue_complementation{ true }; + while (continue_complementation && !worklist.empty()) { + const auto curr_state_set_it{ worklist.back() }; + const State macrostate{ curr_state_set_it->second }; + const StateSet& curr_state_set{ curr_state_set_it->first }; + worklist.pop_back(); + + synchronized_iterator.reset(); + for (const State orig_state: curr_state_set) { mata::utils::push_back(synchronized_iterator, delta[orig_state]); } + bool sync_it_advanced{ synchronized_iterator.advance() }; + auto symbols_it{ symbols.begin() }; + while (sync_it_advanced || symbols_it != symbols_end) { + if (!sync_it_advanced) { + assert(symbols_it != symbols_end); + // There are no more transitions from the 'orig_states' but there is a symbol from the 'symbols'. Make + // the complemented NFA complete by adding a transition to a sink state. We can now return the access + // word for the sink state. + nfa_complete.delta.add(macrostate, *symbols_it, sink_state); + continue_complementation = false; + break; + } + assert(sync_it_advanced); + const std::vector& orig_symbol_posts{ synchronized_iterator.get_current() }; + const Symbol symbol_advanced_to{ (*orig_symbol_posts.begin())->symbol }; + StateSet orig_targets{ synchronized_iterator.unify_targets() }; + Target target_macrostate; + + if (symbols_it == symbols_end || symbol_advanced_to <= *symbols_it) { + // Continue with the determinization of the NFA. + const auto target_macrostate_it = subset_map.find(orig_targets); + if (target_macrostate_it != subset_map.end()) { + target_macrostate = target_macrostate_it->second; + } else { + target_macrostate = nfa_complete.add_state(); + if (!final.intersects_with(orig_targets)) { + nfa_complete.final.insert(target_macrostate); + continue_complementation = false; + } + subset_map_it = subset_map.emplace(std::move(orig_targets), target_macrostate).first; + worklist.emplace_back(subset_map_it.operator->()); + } + nfa_complete.delta.add(macrostate, symbol_advanced_to, target_macrostate); + } else { + assert(symbol_advanced_to > *symbols_it); + // There are more transitions from the 'orig_states', but there is a missing transition over + // '*symbols_it'. Make the complemented NFA complete by adding a transition to a sink state. We can now + // return the access word for the sink state. + nfa_complete.delta.add(macrostate, *symbols_it, sink_state); + continue_complementation = false; + break; + } + + if (!continue_complementation) { break; } + if(symbol_advanced_to >= *symbols_it) { ++symbols_it; } + sync_it_advanced = synchronized_iterator.advance(); + } + } + return nfa_complete.get_word(); +} + +Cntnfa mata::cntnfa::lang_difference( + const Cntnfa& nfa_included, const Cntnfa& nfa_excluded, + std::optional< + std::function + > macrostate_discover +) { + std::unordered_set subset_set_included{}; + std::unordered_set subset_set_excluded{}; + using SubsetMacrostateMap = std::unordered_map::const_pointer, + std::unordered_set::const_pointer + >, State>; + SubsetMacrostateMap subset_macrostate_map{}; + std::vector worklist{}; + + // '{}' represents a sink state that is always final in the complement. + const auto subset_set_excluded_sink_ptr{ subset_set_excluded.insert(StateSet{}).first.operator->() }; + + Cntnfa nfa_lang_difference{}; + const State new_initial{ nfa_lang_difference.add_state() }; + nfa_lang_difference.initial.insert(new_initial); + if (nfa_included.final.intersects_with(nfa_included.initial) && + !nfa_excluded.final.intersects_with(nfa_excluded.initial)) { + nfa_lang_difference.final.insert(new_initial); + } + auto subset_set_included_ptr{ + subset_set_included.emplace(nfa_included.initial).first.operator->() }; + auto subset_set_excluded_ptr{ + subset_set_excluded.emplace(nfa_excluded.initial).first.operator->() }; + auto subset_macrostate_map_ptr{ + subset_macrostate_map.emplace( + std::make_pair(subset_set_included_ptr, subset_set_excluded_ptr), new_initial).first.operator->() }; + worklist.emplace_back(subset_macrostate_map_ptr); + if (macrostate_discover.has_value() + && !(*macrostate_discover)( + nfa_included, nfa_excluded, + *subset_set_included_ptr, *subset_set_excluded_ptr, + new_initial, nfa_lang_difference) + ) { return nfa_lang_difference; } + + using Iterator = mata::utils::OrdVector::const_iterator; + SynchronizedExistentialSymbolPostIterator synchronized_iterator_included{}; + SynchronizedExistentialSymbolPostIterator synchronized_iterator_excluded{}; + + while (!worklist.empty()) { + const auto curr_macrostate_ptr{ worklist.back() }; + worklist.pop_back(); + const auto curr_state_set_included_ptr{ curr_macrostate_ptr->first.first }; + const auto curr_state_set_excluded_ptr{ curr_macrostate_ptr->first.second }; + const StateSet& curr_state_set_included{ *curr_state_set_included_ptr }; + const StateSet& curr_state_set_excluded{ *curr_state_set_excluded_ptr }; + const State macrostate{ curr_macrostate_ptr->second }; + + synchronized_iterator_included.reset(); + synchronized_iterator_excluded.reset(); + for (const State orig_state: curr_state_set_included) { + mata::utils::push_back(synchronized_iterator_included, nfa_included.delta[orig_state]); + } + for (const State orig_state: curr_state_set_excluded) { + mata::utils::push_back(synchronized_iterator_excluded, nfa_excluded.delta[orig_state]); + } + bool sync_it_included_advanced{ synchronized_iterator_included.advance() }; + bool sync_it_excluded_advanced{ false }; + while (sync_it_included_advanced) { + const std::vector& orig_symbol_posts{ synchronized_iterator_included.get_current() }; + const Symbol symbol_advanced_to{ (*orig_symbol_posts.begin())->symbol }; + StateSet orig_targets_included{ synchronized_iterator_included.unify_targets() }; + sync_it_excluded_advanced = synchronized_iterator_excluded.synchronize_with(symbol_advanced_to); + StateSet orig_targets_excluded{ + sync_it_excluded_advanced ? synchronized_iterator_excluded.unify_targets() : StateSet{} + }; + const bool final_included_intersects_targets{ nfa_included.final.intersects_with(orig_targets_included) }; + const bool final_excluded_intersects_targets{ nfa_excluded.final.intersects_with(orig_targets_excluded) }; + subset_set_included_ptr = subset_set_included.insert(std::move(orig_targets_included)).first.operator->(); + subset_set_excluded_ptr = subset_set_excluded.insert(std::move(orig_targets_excluded)).first.operator->(); + const auto [target_macrostate_it, macrostate_inserted]{ subset_macrostate_map.emplace( + std::make_pair(subset_set_included_ptr, subset_set_excluded_ptr), nfa_lang_difference.num_of_states() + ) }; + subset_macrostate_map_ptr = target_macrostate_it.operator->(); + const Target target_macrostate{ target_macrostate_it->second }; + nfa_lang_difference.delta.add(macrostate, symbol_advanced_to, target_macrostate); + if (macrostate_inserted) { + // 'sync_it_excluded_advanced' is true iff there is a transition in the excluded NFA over the symbol + // 'symbol_advanced_to'. If sync_it_excluded_advanced == false, the complement of the excluded NFA will + // have a transition over 'symbol_advanced_to' to a "sink state" which is a final state in the + // complement, and therefore must always be final in the language difference. + if (final_included_intersects_targets) { + if (subset_set_excluded_ptr == subset_set_excluded_sink_ptr + || (sync_it_excluded_advanced && !final_excluded_intersects_targets)) { + nfa_lang_difference.final.insert(target_macrostate); + } + } + if (macrostate_discover.has_value() + && !(*macrostate_discover)( + nfa_included, nfa_excluded, + *subset_set_included_ptr, *subset_set_excluded_ptr, + target_macrostate, nfa_lang_difference)) { return nfa_lang_difference; } + + worklist.emplace_back(subset_macrostate_map_ptr); + } + sync_it_included_advanced = synchronized_iterator_included.advance(); + } + } + return nfa_lang_difference; +} + +std::optional mata::cntnfa::get_word_from_lang_difference(const Cntnfa & nfa_included, const Cntnfa & nfa_excluded) { + return lang_difference(nfa_included, nfa_excluded, + [&](const Cntnfa& nfa_included, const Cntnfa& nfa_excluded, + const StateSet& macrostate_included_state_set, const StateSet& macrostate_excluded_state_set, + const State macrostate, const Cntnfa& nfa_lang_difference) { + (void)nfa_included, (void)nfa_excluded; + (void)macrostate_included_state_set, (void)macrostate_excluded_state_set; + (void)macrostate; + return nfa_lang_difference.final.empty(); + }).get_word(); +} diff --git a/src/cntnfa/product.cc b/src/cntnfa/product.cc new file mode 100644 index 000000000..1fe6ce059 --- /dev/null +++ b/src/cntnfa/product.cc @@ -0,0 +1,370 @@ +/* cntnfa-intersection.cc -- Intersection of NFAs + */ + +// MATA headers +#include "mata/cntnfa/annotations.hh" +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/algorithms.hh" +#include +#include + + +using namespace mata::cntnfa; + +namespace { + +using ProductMap = std::unordered_map,State>; +using MatrixProductStorage = std::vector>; +using VecMapProductStorage = std::vector>; +using InvertedProductStorage = std::vector; +//Unordered map seems to be faster than ordered map here, but still very much slower than matrix. + +} // Anonymous namespace. + +namespace mata::cntnfa { + +Cntnfa mata::cntnfa::algorithms::product_counter_nfas(const Cntnfa& lhs, const Cntnfa& rhs) { + using StatePair = std::pair; + Cntnfa result; + + // Maps state pairs (lhs × rhs) to result states + std::map state_map; + // Queue to process pairs (BFS-like) + std::deque worklist; + + // Helper to get or create a state in the result automaton for a pair of lhs and rhs states + auto get_or_create_state = [&](State lhs_s, State rhs_s) -> State { + StatePair p = {lhs_s, rhs_s}; + auto it = state_map.find(p); + if (it != state_map.end()) { + return it->second; + } + + // Create new state in the result + State new_state = result.add_state(); + state_map[p] = new_state; + worklist.push_back(p); + + // Initial state if both components are initial + if (lhs.initial.contains(lhs_s) && rhs.initial.contains(rhs_s)) { + result.initial.insert(new_state); + } + + // Final state if both components are final + if (lhs.final.contains(lhs_s) && rhs.final.contains(rhs_s)) { + result.final.insert(new_state); + } + + return new_state; + }; + + // Create new counters for both automata in the result automaton + for (size_t i = 0; i < lhs.counter_set.size(); ++i) { + const auto& c = lhs.counter_set.get(i); + result.counter_set.add_with_prefix("c", c.value); + } + for (size_t i = 0; i < rhs.counter_set.size(); ++i) { + const auto& c = rhs.counter_set.get(i); + result.counter_set.add_with_prefix("c", c.value); + } + + // Helper to remap annotation from lhs or rhs to result using new counter names + auto remap_annotation = [&](const std::shared_ptr& ann, const CounterSet& from_set) + -> std::shared_ptr + { + std::string name = from_set.get_name(ann->get_register_id()); + size_t new_id = result.counter_set.get_index(name); + CounterValue val = ann->get_value(); + + // Create a new annotation of the same type with remapped counter ID + if (ann->get_type() == AnnotationType::CounterAssign) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterIncrement) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterEqual) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterNotEqual) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterGreater) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterLess) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterGreaterEqual) return std::make_shared(new_id, val); + if (ann->get_type() == AnnotationType::CounterLessEqual) return std::make_shared(new_id, val); + + throw std::runtime_error("Unknown annotation type"); + }; + + // Initialize product state space from all pairs of initial states + for (auto s1 : lhs.initial) { + for (auto s2 : rhs.initial) { + // Fills state_map and worklist + get_or_create_state(s1, s2); + } + } + + // Process all reachable state pairs + while (!worklist.empty()) { + auto [s1, s2] = worklist.front(); + worklist.pop_front(); + State current = state_map[{s1, s2}]; + + auto it1 = lhs.delta[s1].begin(); + auto it2 = rhs.delta[s2].begin(); + + // Merge transitions by synchronizing on the same symbol + // TODO: Change this to use a synchronized iterator? + while (it1 != lhs.delta[s1].end() && it2 != rhs.delta[s2].end()) { + if (it1->symbol < it2->symbol) { + ++it1; + } else if (it1->symbol > it2->symbol) { + ++it2; + } else { + Symbol symbol = it1->symbol; + // Combined transitions under symbol + SymbolPost product_post{symbol}; + + // For each pair of targets, create a new transition + for (auto tgt1 : it1->targets) { + for (auto tgt2 : it2->targets) { + State tgt = get_or_create_state(tgt1.state, tgt2.state); + + // Merge annotations from both automata + std::vector> all_anns; + if (tgt1.annotations_id != UNDEFINED_ANNOTATIONS) { + for (const auto& ann : lhs.annotation_collection[tgt1.annotations_id]) { + all_anns.push_back(remap_annotation(ann, lhs.counter_set)); + } + } + if (tgt2.annotations_id != UNDEFINED_ANNOTATIONS) { + for (const auto& ann : rhs.annotation_collection[tgt2.annotations_id]) { + all_anns.push_back(remap_annotation(ann, rhs.counter_set)); + } + } + + // Insert the combined annotations into result + size_t ann_set = UNDEFINED_ANNOTATIONS; + if (!all_anns.empty()) { + ann_set = result.annotation_collection.size(); + result.annotation_collection.allocate(ann_set + 1); + for (auto& ann : all_anns) { + result.annotation_collection.insert(ann, ann_set); + } + } + + // Add the final target state with annotations + product_post.insert(AnnotationState(tgt, ann_set)); + } + } + + // Add the transition to the product automaton + result.delta.mutable_state_post(current).push_back(std::move(product_post)); + + // Move to the next transition + ++it1; + ++it2; + } + } + } + + return result; +} + +//TODO: move this method to cntnfa.hh? It is something one might want to use (e.g. for union, inclusion, equivalence of DFAs). +Cntnfa mata::cntnfa::algorithms::product( + const Cntnfa& lhs, const Cntnfa& rhs, const std::function&& final_condition, + const Symbol first_epsilon, ProductMap *product_map) { + + Cntnfa product{}; // The product automaton. + + // Set of product states to process. + std::deque worklist{}; + + //The largest matrix (product_matrix) of pairs of states we are brave enough to allocate. + // Let's say we are fine with allocating large_product * (about 8 Bytes) space. + // So ten million cells is close to 100 MB. + // If the number is larger, then we do not allocate a matrix, but use a vector of unordered maps (product_vec_map). + // The unordered_map seems to be about twice slower. + constexpr size_t MAX_PRODUCT_MATRIX_SIZE = 50'000'000; + //constexpr size_t MAX_PRODUCT_MATRIX_SIZE = 0; + const bool large_product = lhs.num_of_states() * rhs.num_of_states() > MAX_PRODUCT_MATRIX_SIZE; + assert(lhs.num_of_states() < Limits::max_state); + assert(rhs.num_of_states() < Limits::max_state); + + //Two variants of storage for the mapping from pairs of lhs and rhs states to product state, for large and non-large products. + MatrixProductStorage matrix_product_storage; + VecMapProductStorage vec_map_product_storage; + InvertedProductStorage product_to_lhs(lhs.num_of_states()+rhs.num_of_states()); + InvertedProductStorage product_to_rhs(lhs.num_of_states()+rhs.num_of_states()); + + + //Initialize the storage, according to the number of possible state pairs. + if (!large_product) + matrix_product_storage = MatrixProductStorage(lhs.num_of_states(), std::vector(rhs.num_of_states(), Limits::max_state)); + else + vec_map_product_storage = VecMapProductStorage(lhs.num_of_states()); + + /// Give me the product state for the pair of lhs and rhs states. + /// Returns Limits::max_state if not found. + auto get_state_from_product_storage = [&](State lhs_state, State rhs_state) { + if (!large_product) + return matrix_product_storage[lhs_state][rhs_state]; + else { + auto it = vec_map_product_storage[lhs_state].find(rhs_state); + if (it == vec_map_product_storage[lhs_state].end()) + return Limits::max_state; + else + return it->second; + } + }; + + /// Insert new mapping lhs rhs state pair to product state. + auto insert_to_product_storage = [&](State lhs_state, State rhs_state, State product_state) { + if (!large_product) + matrix_product_storage[lhs_state][rhs_state] = product_state; + else + vec_map_product_storage[lhs_state][rhs_state] = product_state; + + product_to_lhs.resize(product_state+1); + product_to_rhs.resize(product_state+1); + product_to_lhs[product_state] = lhs_state; + product_to_rhs[product_state] = rhs_state; + + //this thing is not used internally. It is only used if we want to return the mapping. But it is expensive. + if (product_map != nullptr) + (*product_map)[std::pair(lhs_state,rhs_state)] = product_state; + }; + +/** + * Add symbol_post for the product state (lhs,rhs) to the product, used for epsilons only (it is simpler for normal symbols). + * @param[in] pair_to_process Currently processed pair of original states. + * @param[in] new_product_symbol_post State transitions to add to the product. + */ + auto add_product_e_post = [&](const State lhs_source, const State rhs_source, SymbolPost& new_product_symbol_post) + { + if (new_product_symbol_post.empty()) { return; } + + State product_source = get_state_from_product_storage(lhs_source, rhs_source); + + StatePost &product_state_post{product.delta.mutable_state_post(product_source)}; + + if (product_state_post.empty() || new_product_symbol_post.symbol > product_state_post.back().symbol) { + product_state_post.push_back(std::move(new_product_symbol_post)); + } + else { + auto symbol_post_it = product_state_post.find(new_product_symbol_post.symbol); + if (symbol_post_it == product_state_post.end()) { + product_state_post.insert(std::move(new_product_symbol_post)); + } + //Epsilons are not inserted in order, we insert all lhs epsilons and then all rhs epsilons. + // It can happen that we insert an e-transition from lhs and then another with the same e from rhs. + else { + symbol_post_it->insert(new_product_symbol_post.targets); + } + } + }; + +/** + * Create product state if it does not exist in storage yet and fill in its symbol_post from lhs and rhs targets. + * @param[in] lhs_target Target state in NFA @c lhs. + * @param[in] rhs_target Target state in NFA @c rhs. + * @param[out] product_symbol_post New SymbolPost of the product state. + */ + auto create_product_state_and_symbol_post = [&](const State lhs_target, const State rhs_target, SymbolPost& product_symbol_post) + { + State product_target = get_state_from_product_storage(lhs_target, rhs_target ); + + if ( product_target == Limits::max_state ) + { + product_target = product.add_state(); + assert(product_target < Limits::max_state); + + insert_to_product_storage(lhs_target,rhs_target, product_target); + + worklist.push_back(product_target); + + if (final_condition(lhs_target,rhs_target)) { + product.final.insert(product_target); + } + } + //TODO: Push_back all of them and sort at the could be faster. + product_symbol_post.insert(product_target); + }; + + // Initialize pairs to process with initial state pairs. + for (const State lhs_initial_state : lhs.initial) { + for (const State rhs_initial_state : rhs.initial) { + // Update product with initial state pairs. + const State product_initial_state = product.add_state(); + insert_to_product_storage(lhs_initial_state,rhs_initial_state,product_initial_state); + worklist.push_back(product_initial_state); + product.initial.insert(product_initial_state); + if (final_condition(lhs_initial_state,rhs_initial_state)) { + product.final.insert(product_initial_state); + } + } + } + + while (!worklist.empty()) { + State product_source = worklist.back();; + worklist.pop_back(); + State lhs_source = product_to_lhs[product_source]; + State rhs_source = product_to_rhs[product_source]; + // Compute classic product for current state pair. + + mata::utils::SynchronizedUniversalIterator::const_iterator> sync_iterator(2); + mata::utils::push_back(sync_iterator, lhs.delta[lhs_source]); + mata::utils::push_back(sync_iterator, rhs.delta[rhs_source]); + + while (sync_iterator.advance()) { + const std::vector& same_symbol_posts{ sync_iterator.get_current() }; + assert(same_symbol_posts.size() == 2); // One move per state in the pair. + + // Compute product for state transitions with same symbols. + // Find all transitions that have the same symbol for first and the second state in the pair_to_process. + // Create transition from the pair_to_process to all pairs between states to which first transition goes + // and states to which second one goes. + Symbol symbol = same_symbol_posts[0]->symbol; + if (symbol < first_epsilon) { + SymbolPost product_symbol_post{ symbol }; + for (const State lhs_target: same_symbol_posts[0]->targets) { + for (const State rhs_target: same_symbol_posts[1]->targets) { + create_product_state_and_symbol_post(lhs_target, rhs_target, product_symbol_post); + } + } + StatePost &product_state_post{product.delta.mutable_state_post(product_source)}; + //Here we are sure that we are working with the largest symbol so far, since we iterate through + //the symbol posts of the lhs and rhs in order. So we can just push_back (not insert). + product_state_post.push_back(std::move(product_symbol_post)); + } + else + break; + } + + // Add epsilon transitions, from lhs e-transitions. + const StatePost& lhs_state_post{lhs.delta[lhs_source] }; + + //TODO: handling of epsilons might not be ideal, don't know, it would need some brain cycles to improve. + // (handling of normal symbols is ok though) + auto lhs_first_epsilon_it = lhs_state_post.first_epsilon_it(first_epsilon); + if (lhs_first_epsilon_it != lhs_state_post.end()) { + for (auto lhs_symbol_post = lhs_first_epsilon_it; lhs_symbol_post < lhs_state_post.end(); ++lhs_symbol_post) { + SymbolPost prod_symbol_post{lhs_symbol_post->symbol }; + for (const State lhs_target: lhs_symbol_post->targets) { + create_product_state_and_symbol_post(lhs_target, rhs_source, prod_symbol_post); + } + add_product_e_post(lhs_source, rhs_source, prod_symbol_post); + } + } + + // Add epsilon transitions, from rhs e-transitions. + const StatePost& rhs_state_post{rhs.delta[rhs_source] }; + auto rhs_first_epsilon_it = rhs_state_post.first_epsilon_it(first_epsilon); + if (rhs_first_epsilon_it != rhs_state_post.end()) { + for (auto rhs_symbol_post = rhs_first_epsilon_it; rhs_symbol_post < rhs_state_post.end(); ++rhs_symbol_post) { + SymbolPost prod_symbol_post{rhs_symbol_post->symbol }; + for (const State rhs_target: rhs_symbol_post->targets) { + create_product_state_and_symbol_post(lhs_source, rhs_target, prod_symbol_post); + } + add_product_e_post(lhs_source, rhs_source, prod_symbol_post); + } + } + } + return product; +} // intersection(). + +} // namespace mata::cntnfa. diff --git a/src/cntnfa/registers.cc b/src/cntnfa/registers.cc new file mode 100644 index 000000000..b9bbbe25b --- /dev/null +++ b/src/cntnfa/registers.cc @@ -0,0 +1,117 @@ +// TODO: Insert header file. + +#include +#include +#include + +#include "mata/cntnfa/registers.hh" + +namespace mata::cntnfa { + +/* + Methods for Register. +*/ + +void Register::increment(RegisterValue value) { + if (this->value > std::numeric_limits::max() - value) { + throw std::overflow_error("Register: Increment operation would result in overflow."); + } + this->value += value; +} + +void Register::decrement(RegisterValue value) { + if (value > this->value) { + throw std::underflow_error("Register: Decrement operation would result in a negative value."); + } + this->value -= value; +} + +void Register::set(RegisterValue value) { + if (value < 0) { + throw std::invalid_argument("Register: Value cannot be negative."); + } + this->value = value; +} + +void Register::reset() { + this->value = this->initial_value; +} + +/* + Methods for RegisterSet. +*/ + +void RegisterSet::reserve(const size_t n) { + counters.reserve(n); +} + +void RegisterSet::allocate(const size_t new_size) { + assert(new_size >= counters.size()); + counters.resize(new_size); +} + +size_t RegisterSet::size() const { + return counters.size(); +} + +void RegisterSet::clear() { + counters.clear(); +} + +void RegisterSet::set(size_t index, const Register& counter) { + if (index >= counters.size()) { + this->allocate(index + 1); + } + counters[index] = counter; + name_to_index[counter.name] = index; +} + +size_t RegisterSet::add(const RegisterName& name, RegisterValue value) { + if (name_to_index.contains(name)) { + throw std::invalid_argument("RegisterSet: A register with the same name already exists."); + } + size_t index = counters.size(); + counters.emplace_back(value, name); + name_to_index[name] = index; + return index; +} + +size_t RegisterSet::add_with_prefix(const std::string& prefix, RegisterValue value) { + std::string name = prefix + std::to_string(counters.size()); + return add(name, value); +} + +bool RegisterSet::has(const RegisterName& name) const { + return name_to_index.contains(name); +} + +const RegisterName& RegisterSet::get_name(size_t index) const { + return counters.at(index).name; +} + +std::vector RegisterSet::get_names() const { + std::vector names; + names.reserve(counters.size()); + for (size_t i = 0; i < counters.size(); ++i) { + names.push_back(get_name(i)); + } + return names; +} + +size_t RegisterSet::get_index(const RegisterName& name) const { + auto it = name_to_index.find(name); + if (it != name_to_index.end()) { + return it->second; + } else { + return static_cast(-1); + } +} + +const Register& RegisterSet::get(size_t index) const { + if (index >= counters.size()) { + throw std::out_of_range("RegisterSet: Index out of range."); + } + return counters[index]; +} + +} // namespace mata::cntnfa. diff --git a/src/cntnfa/universal.cc b/src/cntnfa/universal.cc new file mode 100644 index 000000000..ddbf3aed9 --- /dev/null +++ b/src/cntnfa/universal.cc @@ -0,0 +1,156 @@ +/* cntnfa-universal.cc -- NFA universality + */ + +// MATA headers +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/algorithms.hh" +#include "mata/utils/sparse-set.hh" + +using namespace mata::cntnfa; +using namespace mata::utils; + +//TODO: this could be merged with inclusion, or even removed, universality could be implemented using inclusion, +// it is not something needed in practice, so some little overhead is ok + + +/// naive universality check (complementation + emptiness) +bool mata::cntnfa::algorithms::is_universal_naive( + const Cntnfa& aut, + const Alphabet& alphabet, + Run* cex) +{ // {{{ + Cntnfa cmpl = complement(aut, alphabet); + + return cmpl.is_lang_empty(cex); +} // is_universal_naive }}} + + +/// universality check using Antichains +bool mata::cntnfa::algorithms::is_universal_antichains( + const Cntnfa& aut, + const Alphabet& alphabet, + Run* cex) +{ // {{{ + + using WorklistType = std::list; + using ProcessedType = std::list; + + auto subsumes = [](const StateSet& lhs, const StateSet& rhs) { + if (lhs.size() > rhs.size()) { // bigger set cannot be subset + return false; + } + + return std::includes(rhs.begin(), rhs.end(), lhs.begin(), lhs.end()); + }; + + // process parameters + // TODO: set correctly!!!! + bool is_dfs = true; + + // check the initial state + if (are_disjoint(aut.initial, aut.final)) { + if (nullptr != cex) { cex->word.clear(); } + return false; + } + + // initialize + WorklistType worklist = { StateSet(aut.initial) }; + ProcessedType processed = { StateSet(aut.initial) }; + mata::utils::OrdVector alph_symbols = alphabet.get_alphabet_symbols(); + + // 'paths[s] == t' denotes that state 's' was accessed from state 't', + // 'paths[s] == s' means that 's' is an initial state + std::map> paths = + { {StateSet(aut.initial), {StateSet(aut.initial), 0}} }; + + while (!worklist.empty()) { + // get a next state + StateSet state; + if (is_dfs) { + state = *worklist.rbegin(); + worklist.pop_back(); + } else { // BFS + state = *worklist.begin(); + worklist.pop_front(); + } + + // process it + for (Symbol symb : alph_symbols) { + StateSet succ = aut.post(state, symb); + if (!aut.final.intersects_with(succ)) { + if (nullptr != cex) { + cex->word.clear(); + cex->word.push_back(symb); + StateSet trav = state; + while (paths[trav].first != trav) + { // go back until initial state + cex->word.push_back(paths[trav].second); + trav = paths[trav].first; + } + + std::reverse(cex->word.begin(), cex->word.end()); + } + + return false; + } + + bool is_subsumed = false; + for (const auto& anti_state : processed) { + // trying to find a smaller state in processed + if (subsumes(anti_state, succ)) { + is_subsumed = true; + break; + } + } + + if (is_subsumed) { continue; } + + // prune data structures and insert succ inside + for (std::list* ds : {&processed, &worklist}) { + auto it = ds->begin(); + while (it != ds->end()) { + if (subsumes(succ, *it)) { + auto to_remove = it; + ++it; + ds->erase(to_remove); + } else { + ++it; + } + } + + // TODO: set pushing strategy + ds->push_back(succ); + } + + // also set that succ was accessed from state + paths[succ] = {state, symb}; + } + } + + return true; +} // }}} + +// The dispatching method that calls the correct one based on parameters. +bool mata::cntnfa::Cntnfa::is_universal(const Alphabet& alphabet, Run* cex, const ParameterMap& params) const { + // setting the default algorithm + decltype(algorithms::is_universal_naive)* algo = algorithms::is_universal_naive; + if (!haskey(params, "algorithm")) { + throw std::runtime_error(std::to_string(__func__) + + " requires setting the \"algo\" key in the \"params\" argument; " + "received: " + std::to_string(params)); + } + + const std::string& str_algo = params.at("algorithm"); + if ("naive" == str_algo) { /* default */ } + else if ("antichains" == str_algo) { + algo = algorithms::is_universal_antichains; + } else { + throw std::runtime_error(std::to_string(__func__) + + " received an unknown value of the \"algo\" key: " + str_algo); + } + return algo(*this, alphabet, cex); +} // is_universal() + +bool mata::cntnfa::Cntnfa::is_universal(const Alphabet& alphabet, const ParameterMap& params) const { + return this->is_universal(alphabet, nullptr, params); +} diff --git a/tests-integration/cntnfa-bench/README.md b/tests-integration/cntnfa-bench/README.md new file mode 100644 index 000000000..e69de29bb diff --git a/tests-integration/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata b/tests-integration/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata new file mode 100644 index 000000000..e0d13404a --- /dev/null +++ b/tests-integration/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata @@ -0,0 +1,10 @@ +@CNTNFA-explicit +%States q0 q1 q2 +%Alphabet-auto +%Initial q0 +%Final q2 +%Registers c0 +q0 0 (+ c0 1) q0 +q0 1 (> c0 1) (+ c0 -1) q1 +q0 1 (= c0 1) (+ c0 -1) q2 +q1 1 (= c0 1) (+ c0 -1) q2 diff --git a/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1.mata b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1.mata new file mode 100644 index 000000000..a8a057d77 --- /dev/null +++ b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1.mata @@ -0,0 +1,5 @@ +@NFA-explicit +%Initial q0 +%Final q2 +q0 0 q1 +q1 1 q2 diff --git a/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1000.mata b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1000.mata new file mode 100644 index 000000000..9274c3769 --- /dev/null +++ b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1000.mata @@ -0,0 +1,3002 @@ +@NFA-explicit +%Initial q0 +%Final q2000 +q0 0 q1 +q1000 1 q1001 +q1 0 q2 +q1001 1 q1002 +q2 0 q3 +q1002 1 q1003 +q3 0 q4 +q1003 1 q1004 +q4 0 q5 +q1004 1 q1005 +q5 0 q6 +q1005 1 q1006 +q6 0 q7 +q1006 1 q1007 +q7 0 q8 +q1007 1 q1008 +q8 0 q9 +q1008 1 q1009 +q9 0 q10 +q1009 1 q1010 +q10 0 q11 +q1010 1 q1011 +q11 0 q12 +q1011 1 q1012 +q12 0 q13 +q1012 1 q1013 +q13 0 q14 +q1013 1 q1014 +q14 0 q15 +q1014 1 q1015 +q15 0 q16 +q1015 1 q1016 +q16 0 q17 +q1016 1 q1017 +q17 0 q18 +q1017 1 q1018 +q18 0 q19 +q1018 1 q1019 +q19 0 q20 +q1019 1 q1020 +q20 0 q21 +q1020 1 q1021 +q21 0 q22 +q1021 1 q1022 +q22 0 q23 +q1022 1 q1023 +q23 0 q24 +q1023 1 q1024 +q24 0 q25 +q1024 1 q1025 +q25 0 q26 +q1025 1 q1026 +q26 0 q27 +q1026 1 q1027 +q27 0 q28 +q1027 1 q1028 +q28 0 q29 +q1028 1 q1029 +q29 0 q30 +q1029 1 q1030 +q30 0 q31 +q1030 1 q1031 +q31 0 q32 +q1031 1 q1032 +q32 0 q33 +q1032 1 q1033 +q33 0 q34 +q1033 1 q1034 +q34 0 q35 +q1034 1 q1035 +q35 0 q36 +q1035 1 q1036 +q36 0 q37 +q1036 1 q1037 +q37 0 q38 +q1037 1 q1038 +q38 0 q39 +q1038 1 q1039 +q39 0 q40 +q1039 1 q1040 +q40 0 q41 +q1040 1 q1041 +q41 0 q42 +q1041 1 q1042 +q42 0 q43 +q1042 1 q1043 +q43 0 q44 +q1043 1 q1044 +q44 0 q45 +q1044 1 q1045 +q45 0 q46 +q1045 1 q1046 +q46 0 q47 +q1046 1 q1047 +q47 0 q48 +q1047 1 q1048 +q48 0 q49 +q1048 1 q1049 +q49 0 q50 +q1049 1 q1050 +q50 0 q51 +q1050 1 q1051 +q51 0 q52 +q1051 1 q1052 +q52 0 q53 +q1052 1 q1053 +q53 0 q54 +q1053 1 q1054 +q54 0 q55 +q1054 1 q1055 +q55 0 q56 +q1055 1 q1056 +q56 0 q57 +q1056 1 q1057 +q57 0 q58 +q1057 1 q1058 +q58 0 q59 +q1058 1 q1059 +q59 0 q60 +q1059 1 q1060 +q60 0 q61 +q1060 1 q1061 +q61 0 q62 +q1061 1 q1062 +q62 0 q63 +q1062 1 q1063 +q63 0 q64 +q1063 1 q1064 +q64 0 q65 +q1064 1 q1065 +q65 0 q66 +q1065 1 q1066 +q66 0 q67 +q1066 1 q1067 +q67 0 q68 +q1067 1 q1068 +q68 0 q69 +q1068 1 q1069 +q69 0 q70 +q1069 1 q1070 +q70 0 q71 +q1070 1 q1071 +q71 0 q72 +q1071 1 q1072 +q72 0 q73 +q1072 1 q1073 +q73 0 q74 +q1073 1 q1074 +q74 0 q75 +q1074 1 q1075 +q75 0 q76 +q1075 1 q1076 +q76 0 q77 +q1076 1 q1077 +q77 0 q78 +q1077 1 q1078 +q78 0 q79 +q1078 1 q1079 +q79 0 q80 +q1079 1 q1080 +q80 0 q81 +q1080 1 q1081 +q81 0 q82 +q1081 1 q1082 +q82 0 q83 +q1082 1 q1083 +q83 0 q84 +q1083 1 q1084 +q84 0 q85 +q1084 1 q1085 +q85 0 q86 +q1085 1 q1086 +q86 0 q87 +q1086 1 q1087 +q87 0 q88 +q1087 1 q1088 +q88 0 q89 +q1088 1 q1089 +q89 0 q90 +q1089 1 q1090 +q90 0 q91 +q1090 1 q1091 +q91 0 q92 +q1091 1 q1092 +q92 0 q93 +q1092 1 q1093 +q93 0 q94 +q1093 1 q1094 +q94 0 q95 +q1094 1 q1095 +q95 0 q96 +q1095 1 q1096 +q96 0 q97 +q1096 1 q1097 +q97 0 q98 +q1097 1 q1098 +q98 0 q99 +q1098 1 q1099 +q99 0 q100 +q1099 1 q1100 +q100 0 q101 +q1100 1 q1101 +q101 0 q102 +q1101 1 q1102 +q102 0 q103 +q1102 1 q1103 +q103 0 q104 +q1103 1 q1104 +q104 0 q105 +q1104 1 q1105 +q105 0 q106 +q1105 1 q1106 +q106 0 q107 +q1106 1 q1107 +q107 0 q108 +q1107 1 q1108 +q108 0 q109 +q1108 1 q1109 +q109 0 q110 +q1109 1 q1110 +q110 0 q111 +q1110 1 q1111 +q111 0 q112 +q1111 1 q1112 +q112 0 q113 +q1112 1 q1113 +q113 0 q114 +q1113 1 q1114 +q114 0 q115 +q1114 1 q1115 +q115 0 q116 +q1115 1 q1116 +q116 0 q117 +q1116 1 q1117 +q117 0 q118 +q1117 1 q1118 +q118 0 q119 +q1118 1 q1119 +q119 0 q120 +q1119 1 q1120 +q120 0 q121 +q1120 1 q1121 +q121 0 q122 +q1121 1 q1122 +q122 0 q123 +q1122 1 q1123 +q123 0 q124 +q1123 1 q1124 +q124 0 q125 +q1124 1 q1125 +q125 0 q126 +q1125 1 q1126 +q126 0 q127 +q1126 1 q1127 +q127 0 q128 +q1127 1 q1128 +q128 0 q129 +q1128 1 q1129 +q129 0 q130 +q1129 1 q1130 +q130 0 q131 +q1130 1 q1131 +q131 0 q132 +q1131 1 q1132 +q132 0 q133 +q1132 1 q1133 +q133 0 q134 +q1133 1 q1134 +q134 0 q135 +q1134 1 q1135 +q135 0 q136 +q1135 1 q1136 +q136 0 q137 +q1136 1 q1137 +q137 0 q138 +q1137 1 q1138 +q138 0 q139 +q1138 1 q1139 +q139 0 q140 +q1139 1 q1140 +q140 0 q141 +q1140 1 q1141 +q141 0 q142 +q1141 1 q1142 +q142 0 q143 +q1142 1 q1143 +q143 0 q144 +q1143 1 q1144 +q144 0 q145 +q1144 1 q1145 +q145 0 q146 +q1145 1 q1146 +q146 0 q147 +q1146 1 q1147 +q147 0 q148 +q1147 1 q1148 +q148 0 q149 +q1148 1 q1149 +q149 0 q150 +q1149 1 q1150 +q150 0 q151 +q1150 1 q1151 +q151 0 q152 +q1151 1 q1152 +q152 0 q153 +q1152 1 q1153 +q153 0 q154 +q1153 1 q1154 +q154 0 q155 +q1154 1 q1155 +q155 0 q156 +q1155 1 q1156 +q156 0 q157 +q1156 1 q1157 +q157 0 q158 +q1157 1 q1158 +q158 0 q159 +q1158 1 q1159 +q159 0 q160 +q1159 1 q1160 +q160 0 q161 +q1160 1 q1161 +q161 0 q162 +q1161 1 q1162 +q162 0 q163 +q1162 1 q1163 +q163 0 q164 +q1163 1 q1164 +q164 0 q165 +q1164 1 q1165 +q165 0 q166 +q1165 1 q1166 +q166 0 q167 +q1166 1 q1167 +q167 0 q168 +q1167 1 q1168 +q168 0 q169 +q1168 1 q1169 +q169 0 q170 +q1169 1 q1170 +q170 0 q171 +q1170 1 q1171 +q171 0 q172 +q1171 1 q1172 +q172 0 q173 +q1172 1 q1173 +q173 0 q174 +q1173 1 q1174 +q174 0 q175 +q1174 1 q1175 +q175 0 q176 +q1175 1 q1176 +q176 0 q177 +q1176 1 q1177 +q177 0 q178 +q1177 1 q1178 +q178 0 q179 +q1178 1 q1179 +q179 0 q180 +q1179 1 q1180 +q180 0 q181 +q1180 1 q1181 +q181 0 q182 +q1181 1 q1182 +q182 0 q183 +q1182 1 q1183 +q183 0 q184 +q1183 1 q1184 +q184 0 q185 +q1184 1 q1185 +q185 0 q186 +q1185 1 q1186 +q186 0 q187 +q1186 1 q1187 +q187 0 q188 +q1187 1 q1188 +q188 0 q189 +q1188 1 q1189 +q189 0 q190 +q1189 1 q1190 +q190 0 q191 +q1190 1 q1191 +q191 0 q192 +q1191 1 q1192 +q192 0 q193 +q1192 1 q1193 +q193 0 q194 +q1193 1 q1194 +q194 0 q195 +q1194 1 q1195 +q195 0 q196 +q1195 1 q1196 +q196 0 q197 +q1196 1 q1197 +q197 0 q198 +q1197 1 q1198 +q198 0 q199 +q1198 1 q1199 +q199 0 q200 +q1199 1 q1200 +q200 0 q201 +q1200 1 q1201 +q201 0 q202 +q1201 1 q1202 +q202 0 q203 +q1202 1 q1203 +q203 0 q204 +q1203 1 q1204 +q204 0 q205 +q1204 1 q1205 +q205 0 q206 +q1205 1 q1206 +q206 0 q207 +q1206 1 q1207 +q207 0 q208 +q1207 1 q1208 +q208 0 q209 +q1208 1 q1209 +q209 0 q210 +q1209 1 q1210 +q210 0 q211 +q1210 1 q1211 +q211 0 q212 +q1211 1 q1212 +q212 0 q213 +q1212 1 q1213 +q213 0 q214 +q1213 1 q1214 +q214 0 q215 +q1214 1 q1215 +q215 0 q216 +q1215 1 q1216 +q216 0 q217 +q1216 1 q1217 +q217 0 q218 +q1217 1 q1218 +q218 0 q219 +q1218 1 q1219 +q219 0 q220 +q1219 1 q1220 +q220 0 q221 +q1220 1 q1221 +q221 0 q222 +q1221 1 q1222 +q222 0 q223 +q1222 1 q1223 +q223 0 q224 +q1223 1 q1224 +q224 0 q225 +q1224 1 q1225 +q225 0 q226 +q1225 1 q1226 +q226 0 q227 +q1226 1 q1227 +q227 0 q228 +q1227 1 q1228 +q228 0 q229 +q1228 1 q1229 +q229 0 q230 +q1229 1 q1230 +q230 0 q231 +q1230 1 q1231 +q231 0 q232 +q1231 1 q1232 +q232 0 q233 +q1232 1 q1233 +q233 0 q234 +q1233 1 q1234 +q234 0 q235 +q1234 1 q1235 +q235 0 q236 +q1235 1 q1236 +q236 0 q237 +q1236 1 q1237 +q237 0 q238 +q1237 1 q1238 +q238 0 q239 +q1238 1 q1239 +q239 0 q240 +q1239 1 q1240 +q240 0 q241 +q1240 1 q1241 +q241 0 q242 +q1241 1 q1242 +q242 0 q243 +q1242 1 q1243 +q243 0 q244 +q1243 1 q1244 +q244 0 q245 +q1244 1 q1245 +q245 0 q246 +q1245 1 q1246 +q246 0 q247 +q1246 1 q1247 +q247 0 q248 +q1247 1 q1248 +q248 0 q249 +q1248 1 q1249 +q249 0 q250 +q1249 1 q1250 +q250 0 q251 +q1250 1 q1251 +q251 0 q252 +q1251 1 q1252 +q252 0 q253 +q1252 1 q1253 +q253 0 q254 +q1253 1 q1254 +q254 0 q255 +q1254 1 q1255 +q255 0 q256 +q1255 1 q1256 +q256 0 q257 +q1256 1 q1257 +q257 0 q258 +q1257 1 q1258 +q258 0 q259 +q1258 1 q1259 +q259 0 q260 +q1259 1 q1260 +q260 0 q261 +q1260 1 q1261 +q261 0 q262 +q1261 1 q1262 +q262 0 q263 +q1262 1 q1263 +q263 0 q264 +q1263 1 q1264 +q264 0 q265 +q1264 1 q1265 +q265 0 q266 +q1265 1 q1266 +q266 0 q267 +q1266 1 q1267 +q267 0 q268 +q1267 1 q1268 +q268 0 q269 +q1268 1 q1269 +q269 0 q270 +q1269 1 q1270 +q270 0 q271 +q1270 1 q1271 +q271 0 q272 +q1271 1 q1272 +q272 0 q273 +q1272 1 q1273 +q273 0 q274 +q1273 1 q1274 +q274 0 q275 +q1274 1 q1275 +q275 0 q276 +q1275 1 q1276 +q276 0 q277 +q1276 1 q1277 +q277 0 q278 +q1277 1 q1278 +q278 0 q279 +q1278 1 q1279 +q279 0 q280 +q1279 1 q1280 +q280 0 q281 +q1280 1 q1281 +q281 0 q282 +q1281 1 q1282 +q282 0 q283 +q1282 1 q1283 +q283 0 q284 +q1283 1 q1284 +q284 0 q285 +q1284 1 q1285 +q285 0 q286 +q1285 1 q1286 +q286 0 q287 +q1286 1 q1287 +q287 0 q288 +q1287 1 q1288 +q288 0 q289 +q1288 1 q1289 +q289 0 q290 +q1289 1 q1290 +q290 0 q291 +q1290 1 q1291 +q291 0 q292 +q1291 1 q1292 +q292 0 q293 +q1292 1 q1293 +q293 0 q294 +q1293 1 q1294 +q294 0 q295 +q1294 1 q1295 +q295 0 q296 +q1295 1 q1296 +q296 0 q297 +q1296 1 q1297 +q297 0 q298 +q1297 1 q1298 +q298 0 q299 +q1298 1 q1299 +q299 0 q300 +q1299 1 q1300 +q300 0 q301 +q1300 1 q1301 +q301 0 q302 +q1301 1 q1302 +q302 0 q303 +q1302 1 q1303 +q303 0 q304 +q1303 1 q1304 +q304 0 q305 +q1304 1 q1305 +q305 0 q306 +q1305 1 q1306 +q306 0 q307 +q1306 1 q1307 +q307 0 q308 +q1307 1 q1308 +q308 0 q309 +q1308 1 q1309 +q309 0 q310 +q1309 1 q1310 +q310 0 q311 +q1310 1 q1311 +q311 0 q312 +q1311 1 q1312 +q312 0 q313 +q1312 1 q1313 +q313 0 q314 +q1313 1 q1314 +q314 0 q315 +q1314 1 q1315 +q315 0 q316 +q1315 1 q1316 +q316 0 q317 +q1316 1 q1317 +q317 0 q318 +q1317 1 q1318 +q318 0 q319 +q1318 1 q1319 +q319 0 q320 +q1319 1 q1320 +q320 0 q321 +q1320 1 q1321 +q321 0 q322 +q1321 1 q1322 +q322 0 q323 +q1322 1 q1323 +q323 0 q324 +q1323 1 q1324 +q324 0 q325 +q1324 1 q1325 +q325 0 q326 +q1325 1 q1326 +q326 0 q327 +q1326 1 q1327 +q327 0 q328 +q1327 1 q1328 +q328 0 q329 +q1328 1 q1329 +q329 0 q330 +q1329 1 q1330 +q330 0 q331 +q1330 1 q1331 +q331 0 q332 +q1331 1 q1332 +q332 0 q333 +q1332 1 q1333 +q333 0 q334 +q1333 1 q1334 +q334 0 q335 +q1334 1 q1335 +q335 0 q336 +q1335 1 q1336 +q336 0 q337 +q1336 1 q1337 +q337 0 q338 +q1337 1 q1338 +q338 0 q339 +q1338 1 q1339 +q339 0 q340 +q1339 1 q1340 +q340 0 q341 +q1340 1 q1341 +q341 0 q342 +q1341 1 q1342 +q342 0 q343 +q1342 1 q1343 +q343 0 q344 +q1343 1 q1344 +q344 0 q345 +q1344 1 q1345 +q345 0 q346 +q1345 1 q1346 +q346 0 q347 +q1346 1 q1347 +q347 0 q348 +q1347 1 q1348 +q348 0 q349 +q1348 1 q1349 +q349 0 q350 +q1349 1 q1350 +q350 0 q351 +q1350 1 q1351 +q351 0 q352 +q1351 1 q1352 +q352 0 q353 +q1352 1 q1353 +q353 0 q354 +q1353 1 q1354 +q354 0 q355 +q1354 1 q1355 +q355 0 q356 +q1355 1 q1356 +q356 0 q357 +q1356 1 q1357 +q357 0 q358 +q1357 1 q1358 +q358 0 q359 +q1358 1 q1359 +q359 0 q360 +q1359 1 q1360 +q360 0 q361 +q1360 1 q1361 +q361 0 q362 +q1361 1 q1362 +q362 0 q363 +q1362 1 q1363 +q363 0 q364 +q1363 1 q1364 +q364 0 q365 +q1364 1 q1365 +q365 0 q366 +q1365 1 q1366 +q366 0 q367 +q1366 1 q1367 +q367 0 q368 +q1367 1 q1368 +q368 0 q369 +q1368 1 q1369 +q369 0 q370 +q1369 1 q1370 +q370 0 q371 +q1370 1 q1371 +q371 0 q372 +q1371 1 q1372 +q372 0 q373 +q1372 1 q1373 +q373 0 q374 +q1373 1 q1374 +q374 0 q375 +q1374 1 q1375 +q375 0 q376 +q1375 1 q1376 +q376 0 q377 +q1376 1 q1377 +q377 0 q378 +q1377 1 q1378 +q378 0 q379 +q1378 1 q1379 +q379 0 q380 +q1379 1 q1380 +q380 0 q381 +q1380 1 q1381 +q381 0 q382 +q1381 1 q1382 +q382 0 q383 +q1382 1 q1383 +q383 0 q384 +q1383 1 q1384 +q384 0 q385 +q1384 1 q1385 +q385 0 q386 +q1385 1 q1386 +q386 0 q387 +q1386 1 q1387 +q387 0 q388 +q1387 1 q1388 +q388 0 q389 +q1388 1 q1389 +q389 0 q390 +q1389 1 q1390 +q390 0 q391 +q1390 1 q1391 +q391 0 q392 +q1391 1 q1392 +q392 0 q393 +q1392 1 q1393 +q393 0 q394 +q1393 1 q1394 +q394 0 q395 +q1394 1 q1395 +q395 0 q396 +q1395 1 q1396 +q396 0 q397 +q1396 1 q1397 +q397 0 q398 +q1397 1 q1398 +q398 0 q399 +q1398 1 q1399 +q399 0 q400 +q1399 1 q1400 +q400 0 q401 +q1400 1 q1401 +q401 0 q402 +q1401 1 q1402 +q402 0 q403 +q1402 1 q1403 +q403 0 q404 +q1403 1 q1404 +q404 0 q405 +q1404 1 q1405 +q405 0 q406 +q1405 1 q1406 +q406 0 q407 +q1406 1 q1407 +q407 0 q408 +q1407 1 q1408 +q408 0 q409 +q1408 1 q1409 +q409 0 q410 +q1409 1 q1410 +q410 0 q411 +q1410 1 q1411 +q411 0 q412 +q1411 1 q1412 +q412 0 q413 +q1412 1 q1413 +q413 0 q414 +q1413 1 q1414 +q414 0 q415 +q1414 1 q1415 +q415 0 q416 +q1415 1 q1416 +q416 0 q417 +q1416 1 q1417 +q417 0 q418 +q1417 1 q1418 +q418 0 q419 +q1418 1 q1419 +q419 0 q420 +q1419 1 q1420 +q420 0 q421 +q1420 1 q1421 +q421 0 q422 +q1421 1 q1422 +q422 0 q423 +q1422 1 q1423 +q423 0 q424 +q1423 1 q1424 +q424 0 q425 +q1424 1 q1425 +q425 0 q426 +q1425 1 q1426 +q426 0 q427 +q1426 1 q1427 +q427 0 q428 +q1427 1 q1428 +q428 0 q429 +q1428 1 q1429 +q429 0 q430 +q1429 1 q1430 +q430 0 q431 +q1430 1 q1431 +q431 0 q432 +q1431 1 q1432 +q432 0 q433 +q1432 1 q1433 +q433 0 q434 +q1433 1 q1434 +q434 0 q435 +q1434 1 q1435 +q435 0 q436 +q1435 1 q1436 +q436 0 q437 +q1436 1 q1437 +q437 0 q438 +q1437 1 q1438 +q438 0 q439 +q1438 1 q1439 +q439 0 q440 +q1439 1 q1440 +q440 0 q441 +q1440 1 q1441 +q441 0 q442 +q1441 1 q1442 +q442 0 q443 +q1442 1 q1443 +q443 0 q444 +q1443 1 q1444 +q444 0 q445 +q1444 1 q1445 +q445 0 q446 +q1445 1 q1446 +q446 0 q447 +q1446 1 q1447 +q447 0 q448 +q1447 1 q1448 +q448 0 q449 +q1448 1 q1449 +q449 0 q450 +q1449 1 q1450 +q450 0 q451 +q1450 1 q1451 +q451 0 q452 +q1451 1 q1452 +q452 0 q453 +q1452 1 q1453 +q453 0 q454 +q1453 1 q1454 +q454 0 q455 +q1454 1 q1455 +q455 0 q456 +q1455 1 q1456 +q456 0 q457 +q1456 1 q1457 +q457 0 q458 +q1457 1 q1458 +q458 0 q459 +q1458 1 q1459 +q459 0 q460 +q1459 1 q1460 +q460 0 q461 +q1460 1 q1461 +q461 0 q462 +q1461 1 q1462 +q462 0 q463 +q1462 1 q1463 +q463 0 q464 +q1463 1 q1464 +q464 0 q465 +q1464 1 q1465 +q465 0 q466 +q1465 1 q1466 +q466 0 q467 +q1466 1 q1467 +q467 0 q468 +q1467 1 q1468 +q468 0 q469 +q1468 1 q1469 +q469 0 q470 +q1469 1 q1470 +q470 0 q471 +q1470 1 q1471 +q471 0 q472 +q1471 1 q1472 +q472 0 q473 +q1472 1 q1473 +q473 0 q474 +q1473 1 q1474 +q474 0 q475 +q1474 1 q1475 +q475 0 q476 +q1475 1 q1476 +q476 0 q477 +q1476 1 q1477 +q477 0 q478 +q1477 1 q1478 +q478 0 q479 +q1478 1 q1479 +q479 0 q480 +q1479 1 q1480 +q480 0 q481 +q1480 1 q1481 +q481 0 q482 +q1481 1 q1482 +q482 0 q483 +q1482 1 q1483 +q483 0 q484 +q1483 1 q1484 +q484 0 q485 +q1484 1 q1485 +q485 0 q486 +q1485 1 q1486 +q486 0 q487 +q1486 1 q1487 +q487 0 q488 +q1487 1 q1488 +q488 0 q489 +q1488 1 q1489 +q489 0 q490 +q1489 1 q1490 +q490 0 q491 +q1490 1 q1491 +q491 0 q492 +q1491 1 q1492 +q492 0 q493 +q1492 1 q1493 +q493 0 q494 +q1493 1 q1494 +q494 0 q495 +q1494 1 q1495 +q495 0 q496 +q1495 1 q1496 +q496 0 q497 +q1496 1 q1497 +q497 0 q498 +q1497 1 q1498 +q498 0 q499 +q1498 1 q1499 +q499 0 q500 +q1499 1 q1500 +q500 0 q501 +q1500 1 q1501 +q501 0 q502 +q1501 1 q1502 +q502 0 q503 +q1502 1 q1503 +q503 0 q504 +q1503 1 q1504 +q504 0 q505 +q1504 1 q1505 +q505 0 q506 +q1505 1 q1506 +q506 0 q507 +q1506 1 q1507 +q507 0 q508 +q1507 1 q1508 +q508 0 q509 +q1508 1 q1509 +q509 0 q510 +q1509 1 q1510 +q510 0 q511 +q1510 1 q1511 +q511 0 q512 +q1511 1 q1512 +q512 0 q513 +q1512 1 q1513 +q513 0 q514 +q1513 1 q1514 +q514 0 q515 +q1514 1 q1515 +q515 0 q516 +q1515 1 q1516 +q516 0 q517 +q1516 1 q1517 +q517 0 q518 +q1517 1 q1518 +q518 0 q519 +q1518 1 q1519 +q519 0 q520 +q1519 1 q1520 +q520 0 q521 +q1520 1 q1521 +q521 0 q522 +q1521 1 q1522 +q522 0 q523 +q1522 1 q1523 +q523 0 q524 +q1523 1 q1524 +q524 0 q525 +q1524 1 q1525 +q525 0 q526 +q1525 1 q1526 +q526 0 q527 +q1526 1 q1527 +q527 0 q528 +q1527 1 q1528 +q528 0 q529 +q1528 1 q1529 +q529 0 q530 +q1529 1 q1530 +q530 0 q531 +q1530 1 q1531 +q531 0 q532 +q1531 1 q1532 +q532 0 q533 +q1532 1 q1533 +q533 0 q534 +q1533 1 q1534 +q534 0 q535 +q1534 1 q1535 +q535 0 q536 +q1535 1 q1536 +q536 0 q537 +q1536 1 q1537 +q537 0 q538 +q1537 1 q1538 +q538 0 q539 +q1538 1 q1539 +q539 0 q540 +q1539 1 q1540 +q540 0 q541 +q1540 1 q1541 +q541 0 q542 +q1541 1 q1542 +q542 0 q543 +q1542 1 q1543 +q543 0 q544 +q1543 1 q1544 +q544 0 q545 +q1544 1 q1545 +q545 0 q546 +q1545 1 q1546 +q546 0 q547 +q1546 1 q1547 +q547 0 q548 +q1547 1 q1548 +q548 0 q549 +q1548 1 q1549 +q549 0 q550 +q1549 1 q1550 +q550 0 q551 +q1550 1 q1551 +q551 0 q552 +q1551 1 q1552 +q552 0 q553 +q1552 1 q1553 +q553 0 q554 +q1553 1 q1554 +q554 0 q555 +q1554 1 q1555 +q555 0 q556 +q1555 1 q1556 +q556 0 q557 +q1556 1 q1557 +q557 0 q558 +q1557 1 q1558 +q558 0 q559 +q1558 1 q1559 +q559 0 q560 +q1559 1 q1560 +q560 0 q561 +q1560 1 q1561 +q561 0 q562 +q1561 1 q1562 +q562 0 q563 +q1562 1 q1563 +q563 0 q564 +q1563 1 q1564 +q564 0 q565 +q1564 1 q1565 +q565 0 q566 +q1565 1 q1566 +q566 0 q567 +q1566 1 q1567 +q567 0 q568 +q1567 1 q1568 +q568 0 q569 +q1568 1 q1569 +q569 0 q570 +q1569 1 q1570 +q570 0 q571 +q1570 1 q1571 +q571 0 q572 +q1571 1 q1572 +q572 0 q573 +q1572 1 q1573 +q573 0 q574 +q1573 1 q1574 +q574 0 q575 +q1574 1 q1575 +q575 0 q576 +q1575 1 q1576 +q576 0 q577 +q1576 1 q1577 +q577 0 q578 +q1577 1 q1578 +q578 0 q579 +q1578 1 q1579 +q579 0 q580 +q1579 1 q1580 +q580 0 q581 +q1580 1 q1581 +q581 0 q582 +q1581 1 q1582 +q582 0 q583 +q1582 1 q1583 +q583 0 q584 +q1583 1 q1584 +q584 0 q585 +q1584 1 q1585 +q585 0 q586 +q1585 1 q1586 +q586 0 q587 +q1586 1 q1587 +q587 0 q588 +q1587 1 q1588 +q588 0 q589 +q1588 1 q1589 +q589 0 q590 +q1589 1 q1590 +q590 0 q591 +q1590 1 q1591 +q591 0 q592 +q1591 1 q1592 +q592 0 q593 +q1592 1 q1593 +q593 0 q594 +q1593 1 q1594 +q594 0 q595 +q1594 1 q1595 +q595 0 q596 +q1595 1 q1596 +q596 0 q597 +q1596 1 q1597 +q597 0 q598 +q1597 1 q1598 +q598 0 q599 +q1598 1 q1599 +q599 0 q600 +q1599 1 q1600 +q600 0 q601 +q1600 1 q1601 +q601 0 q602 +q1601 1 q1602 +q602 0 q603 +q1602 1 q1603 +q603 0 q604 +q1603 1 q1604 +q604 0 q605 +q1604 1 q1605 +q605 0 q606 +q1605 1 q1606 +q606 0 q607 +q1606 1 q1607 +q607 0 q608 +q1607 1 q1608 +q608 0 q609 +q1608 1 q1609 +q609 0 q610 +q1609 1 q1610 +q610 0 q611 +q1610 1 q1611 +q611 0 q612 +q1611 1 q1612 +q612 0 q613 +q1612 1 q1613 +q613 0 q614 +q1613 1 q1614 +q614 0 q615 +q1614 1 q1615 +q615 0 q616 +q1615 1 q1616 +q616 0 q617 +q1616 1 q1617 +q617 0 q618 +q1617 1 q1618 +q618 0 q619 +q1618 1 q1619 +q619 0 q620 +q1619 1 q1620 +q620 0 q621 +q1620 1 q1621 +q621 0 q622 +q1621 1 q1622 +q622 0 q623 +q1622 1 q1623 +q623 0 q624 +q1623 1 q1624 +q624 0 q625 +q1624 1 q1625 +q625 0 q626 +q1625 1 q1626 +q626 0 q627 +q1626 1 q1627 +q627 0 q628 +q1627 1 q1628 +q628 0 q629 +q1628 1 q1629 +q629 0 q630 +q1629 1 q1630 +q630 0 q631 +q1630 1 q1631 +q631 0 q632 +q1631 1 q1632 +q632 0 q633 +q1632 1 q1633 +q633 0 q634 +q1633 1 q1634 +q634 0 q635 +q1634 1 q1635 +q635 0 q636 +q1635 1 q1636 +q636 0 q637 +q1636 1 q1637 +q637 0 q638 +q1637 1 q1638 +q638 0 q639 +q1638 1 q1639 +q639 0 q640 +q1639 1 q1640 +q640 0 q641 +q1640 1 q1641 +q641 0 q642 +q1641 1 q1642 +q642 0 q643 +q1642 1 q1643 +q643 0 q644 +q1643 1 q1644 +q644 0 q645 +q1644 1 q1645 +q645 0 q646 +q1645 1 q1646 +q646 0 q647 +q1646 1 q1647 +q647 0 q648 +q1647 1 q1648 +q648 0 q649 +q1648 1 q1649 +q649 0 q650 +q1649 1 q1650 +q650 0 q651 +q1650 1 q1651 +q651 0 q652 +q1651 1 q1652 +q652 0 q653 +q1652 1 q1653 +q653 0 q654 +q1653 1 q1654 +q654 0 q655 +q1654 1 q1655 +q655 0 q656 +q1655 1 q1656 +q656 0 q657 +q1656 1 q1657 +q657 0 q658 +q1657 1 q1658 +q658 0 q659 +q1658 1 q1659 +q659 0 q660 +q1659 1 q1660 +q660 0 q661 +q1660 1 q1661 +q661 0 q662 +q1661 1 q1662 +q662 0 q663 +q1662 1 q1663 +q663 0 q664 +q1663 1 q1664 +q664 0 q665 +q1664 1 q1665 +q665 0 q666 +q1665 1 q1666 +q666 0 q667 +q1666 1 q1667 +q667 0 q668 +q1667 1 q1668 +q668 0 q669 +q1668 1 q1669 +q669 0 q670 +q1669 1 q1670 +q670 0 q671 +q1670 1 q1671 +q671 0 q672 +q1671 1 q1672 +q672 0 q673 +q1672 1 q1673 +q673 0 q674 +q1673 1 q1674 +q674 0 q675 +q1674 1 q1675 +q675 0 q676 +q1675 1 q1676 +q676 0 q677 +q1676 1 q1677 +q677 0 q678 +q1677 1 q1678 +q678 0 q679 +q1678 1 q1679 +q679 0 q680 +q1679 1 q1680 +q680 0 q681 +q1680 1 q1681 +q681 0 q682 +q1681 1 q1682 +q682 0 q683 +q1682 1 q1683 +q683 0 q684 +q1683 1 q1684 +q684 0 q685 +q1684 1 q1685 +q685 0 q686 +q1685 1 q1686 +q686 0 q687 +q1686 1 q1687 +q687 0 q688 +q1687 1 q1688 +q688 0 q689 +q1688 1 q1689 +q689 0 q690 +q1689 1 q1690 +q690 0 q691 +q1690 1 q1691 +q691 0 q692 +q1691 1 q1692 +q692 0 q693 +q1692 1 q1693 +q693 0 q694 +q1693 1 q1694 +q694 0 q695 +q1694 1 q1695 +q695 0 q696 +q1695 1 q1696 +q696 0 q697 +q1696 1 q1697 +q697 0 q698 +q1697 1 q1698 +q698 0 q699 +q1698 1 q1699 +q699 0 q700 +q1699 1 q1700 +q700 0 q701 +q1700 1 q1701 +q701 0 q702 +q1701 1 q1702 +q702 0 q703 +q1702 1 q1703 +q703 0 q704 +q1703 1 q1704 +q704 0 q705 +q1704 1 q1705 +q705 0 q706 +q1705 1 q1706 +q706 0 q707 +q1706 1 q1707 +q707 0 q708 +q1707 1 q1708 +q708 0 q709 +q1708 1 q1709 +q709 0 q710 +q1709 1 q1710 +q710 0 q711 +q1710 1 q1711 +q711 0 q712 +q1711 1 q1712 +q712 0 q713 +q1712 1 q1713 +q713 0 q714 +q1713 1 q1714 +q714 0 q715 +q1714 1 q1715 +q715 0 q716 +q1715 1 q1716 +q716 0 q717 +q1716 1 q1717 +q717 0 q718 +q1717 1 q1718 +q718 0 q719 +q1718 1 q1719 +q719 0 q720 +q1719 1 q1720 +q720 0 q721 +q1720 1 q1721 +q721 0 q722 +q1721 1 q1722 +q722 0 q723 +q1722 1 q1723 +q723 0 q724 +q1723 1 q1724 +q724 0 q725 +q1724 1 q1725 +q725 0 q726 +q1725 1 q1726 +q726 0 q727 +q1726 1 q1727 +q727 0 q728 +q1727 1 q1728 +q728 0 q729 +q1728 1 q1729 +q729 0 q730 +q1729 1 q1730 +q730 0 q731 +q1730 1 q1731 +q731 0 q732 +q1731 1 q1732 +q732 0 q733 +q1732 1 q1733 +q733 0 q734 +q1733 1 q1734 +q734 0 q735 +q1734 1 q1735 +q735 0 q736 +q1735 1 q1736 +q736 0 q737 +q1736 1 q1737 +q737 0 q738 +q1737 1 q1738 +q738 0 q739 +q1738 1 q1739 +q739 0 q740 +q1739 1 q1740 +q740 0 q741 +q1740 1 q1741 +q741 0 q742 +q1741 1 q1742 +q742 0 q743 +q1742 1 q1743 +q743 0 q744 +q1743 1 q1744 +q744 0 q745 +q1744 1 q1745 +q745 0 q746 +q1745 1 q1746 +q746 0 q747 +q1746 1 q1747 +q747 0 q748 +q1747 1 q1748 +q748 0 q749 +q1748 1 q1749 +q749 0 q750 +q1749 1 q1750 +q750 0 q751 +q1750 1 q1751 +q751 0 q752 +q1751 1 q1752 +q752 0 q753 +q1752 1 q1753 +q753 0 q754 +q1753 1 q1754 +q754 0 q755 +q1754 1 q1755 +q755 0 q756 +q1755 1 q1756 +q756 0 q757 +q1756 1 q1757 +q757 0 q758 +q1757 1 q1758 +q758 0 q759 +q1758 1 q1759 +q759 0 q760 +q1759 1 q1760 +q760 0 q761 +q1760 1 q1761 +q761 0 q762 +q1761 1 q1762 +q762 0 q763 +q1762 1 q1763 +q763 0 q764 +q1763 1 q1764 +q764 0 q765 +q1764 1 q1765 +q765 0 q766 +q1765 1 q1766 +q766 0 q767 +q1766 1 q1767 +q767 0 q768 +q1767 1 q1768 +q768 0 q769 +q1768 1 q1769 +q769 0 q770 +q1769 1 q1770 +q770 0 q771 +q1770 1 q1771 +q771 0 q772 +q1771 1 q1772 +q772 0 q773 +q1772 1 q1773 +q773 0 q774 +q1773 1 q1774 +q774 0 q775 +q1774 1 q1775 +q775 0 q776 +q1775 1 q1776 +q776 0 q777 +q1776 1 q1777 +q777 0 q778 +q1777 1 q1778 +q778 0 q779 +q1778 1 q1779 +q779 0 q780 +q1779 1 q1780 +q780 0 q781 +q1780 1 q1781 +q781 0 q782 +q1781 1 q1782 +q782 0 q783 +q1782 1 q1783 +q783 0 q784 +q1783 1 q1784 +q784 0 q785 +q1784 1 q1785 +q785 0 q786 +q1785 1 q1786 +q786 0 q787 +q1786 1 q1787 +q787 0 q788 +q1787 1 q1788 +q788 0 q789 +q1788 1 q1789 +q789 0 q790 +q1789 1 q1790 +q790 0 q791 +q1790 1 q1791 +q791 0 q792 +q1791 1 q1792 +q792 0 q793 +q1792 1 q1793 +q793 0 q794 +q1793 1 q1794 +q794 0 q795 +q1794 1 q1795 +q795 0 q796 +q1795 1 q1796 +q796 0 q797 +q1796 1 q1797 +q797 0 q798 +q1797 1 q1798 +q798 0 q799 +q1798 1 q1799 +q799 0 q800 +q1799 1 q1800 +q800 0 q801 +q1800 1 q1801 +q801 0 q802 +q1801 1 q1802 +q802 0 q803 +q1802 1 q1803 +q803 0 q804 +q1803 1 q1804 +q804 0 q805 +q1804 1 q1805 +q805 0 q806 +q1805 1 q1806 +q806 0 q807 +q1806 1 q1807 +q807 0 q808 +q1807 1 q1808 +q808 0 q809 +q1808 1 q1809 +q809 0 q810 +q1809 1 q1810 +q810 0 q811 +q1810 1 q1811 +q811 0 q812 +q1811 1 q1812 +q812 0 q813 +q1812 1 q1813 +q813 0 q814 +q1813 1 q1814 +q814 0 q815 +q1814 1 q1815 +q815 0 q816 +q1815 1 q1816 +q816 0 q817 +q1816 1 q1817 +q817 0 q818 +q1817 1 q1818 +q818 0 q819 +q1818 1 q1819 +q819 0 q820 +q1819 1 q1820 +q820 0 q821 +q1820 1 q1821 +q821 0 q822 +q1821 1 q1822 +q822 0 q823 +q1822 1 q1823 +q823 0 q824 +q1823 1 q1824 +q824 0 q825 +q1824 1 q1825 +q825 0 q826 +q1825 1 q1826 +q826 0 q827 +q1826 1 q1827 +q827 0 q828 +q1827 1 q1828 +q828 0 q829 +q1828 1 q1829 +q829 0 q830 +q1829 1 q1830 +q830 0 q831 +q1830 1 q1831 +q831 0 q832 +q1831 1 q1832 +q832 0 q833 +q1832 1 q1833 +q833 0 q834 +q1833 1 q1834 +q834 0 q835 +q1834 1 q1835 +q835 0 q836 +q1835 1 q1836 +q836 0 q837 +q1836 1 q1837 +q837 0 q838 +q1837 1 q1838 +q838 0 q839 +q1838 1 q1839 +q839 0 q840 +q1839 1 q1840 +q840 0 q841 +q1840 1 q1841 +q841 0 q842 +q1841 1 q1842 +q842 0 q843 +q1842 1 q1843 +q843 0 q844 +q1843 1 q1844 +q844 0 q845 +q1844 1 q1845 +q845 0 q846 +q1845 1 q1846 +q846 0 q847 +q1846 1 q1847 +q847 0 q848 +q1847 1 q1848 +q848 0 q849 +q1848 1 q1849 +q849 0 q850 +q1849 1 q1850 +q850 0 q851 +q1850 1 q1851 +q851 0 q852 +q1851 1 q1852 +q852 0 q853 +q1852 1 q1853 +q853 0 q854 +q1853 1 q1854 +q854 0 q855 +q1854 1 q1855 +q855 0 q856 +q1855 1 q1856 +q856 0 q857 +q1856 1 q1857 +q857 0 q858 +q1857 1 q1858 +q858 0 q859 +q1858 1 q1859 +q859 0 q860 +q1859 1 q1860 +q860 0 q861 +q1860 1 q1861 +q861 0 q862 +q1861 1 q1862 +q862 0 q863 +q1862 1 q1863 +q863 0 q864 +q1863 1 q1864 +q864 0 q865 +q1864 1 q1865 +q865 0 q866 +q1865 1 q1866 +q866 0 q867 +q1866 1 q1867 +q867 0 q868 +q1867 1 q1868 +q868 0 q869 +q1868 1 q1869 +q869 0 q870 +q1869 1 q1870 +q870 0 q871 +q1870 1 q1871 +q871 0 q872 +q1871 1 q1872 +q872 0 q873 +q1872 1 q1873 +q873 0 q874 +q1873 1 q1874 +q874 0 q875 +q1874 1 q1875 +q875 0 q876 +q1875 1 q1876 +q876 0 q877 +q1876 1 q1877 +q877 0 q878 +q1877 1 q1878 +q878 0 q879 +q1878 1 q1879 +q879 0 q880 +q1879 1 q1880 +q880 0 q881 +q1880 1 q1881 +q881 0 q882 +q1881 1 q1882 +q882 0 q883 +q1882 1 q1883 +q883 0 q884 +q1883 1 q1884 +q884 0 q885 +q1884 1 q1885 +q885 0 q886 +q1885 1 q1886 +q886 0 q887 +q1886 1 q1887 +q887 0 q888 +q1887 1 q1888 +q888 0 q889 +q1888 1 q1889 +q889 0 q890 +q1889 1 q1890 +q890 0 q891 +q1890 1 q1891 +q891 0 q892 +q1891 1 q1892 +q892 0 q893 +q1892 1 q1893 +q893 0 q894 +q1893 1 q1894 +q894 0 q895 +q1894 1 q1895 +q895 0 q896 +q1895 1 q1896 +q896 0 q897 +q1896 1 q1897 +q897 0 q898 +q1897 1 q1898 +q898 0 q899 +q1898 1 q1899 +q899 0 q900 +q1899 1 q1900 +q900 0 q901 +q1900 1 q1901 +q901 0 q902 +q1901 1 q1902 +q902 0 q903 +q1902 1 q1903 +q903 0 q904 +q1903 1 q1904 +q904 0 q905 +q1904 1 q1905 +q905 0 q906 +q1905 1 q1906 +q906 0 q907 +q1906 1 q1907 +q907 0 q908 +q1907 1 q1908 +q908 0 q909 +q1908 1 q1909 +q909 0 q910 +q1909 1 q1910 +q910 0 q911 +q1910 1 q1911 +q911 0 q912 +q1911 1 q1912 +q912 0 q913 +q1912 1 q1913 +q913 0 q914 +q1913 1 q1914 +q914 0 q915 +q1914 1 q1915 +q915 0 q916 +q1915 1 q1916 +q916 0 q917 +q1916 1 q1917 +q917 0 q918 +q1917 1 q1918 +q918 0 q919 +q1918 1 q1919 +q919 0 q920 +q1919 1 q1920 +q920 0 q921 +q1920 1 q1921 +q921 0 q922 +q1921 1 q1922 +q922 0 q923 +q1922 1 q1923 +q923 0 q924 +q1923 1 q1924 +q924 0 q925 +q1924 1 q1925 +q925 0 q926 +q1925 1 q1926 +q926 0 q927 +q1926 1 q1927 +q927 0 q928 +q1927 1 q1928 +q928 0 q929 +q1928 1 q1929 +q929 0 q930 +q1929 1 q1930 +q930 0 q931 +q1930 1 q1931 +q931 0 q932 +q1931 1 q1932 +q932 0 q933 +q1932 1 q1933 +q933 0 q934 +q1933 1 q1934 +q934 0 q935 +q1934 1 q1935 +q935 0 q936 +q1935 1 q1936 +q936 0 q937 +q1936 1 q1937 +q937 0 q938 +q1937 1 q1938 +q938 0 q939 +q1938 1 q1939 +q939 0 q940 +q1939 1 q1940 +q940 0 q941 +q1940 1 q1941 +q941 0 q942 +q1941 1 q1942 +q942 0 q943 +q1942 1 q1943 +q943 0 q944 +q1943 1 q1944 +q944 0 q945 +q1944 1 q1945 +q945 0 q946 +q1945 1 q1946 +q946 0 q947 +q1946 1 q1947 +q947 0 q948 +q1947 1 q1948 +q948 0 q949 +q1948 1 q1949 +q949 0 q950 +q1949 1 q1950 +q950 0 q951 +q1950 1 q1951 +q951 0 q952 +q1951 1 q1952 +q952 0 q953 +q1952 1 q1953 +q953 0 q954 +q1953 1 q1954 +q954 0 q955 +q1954 1 q1955 +q955 0 q956 +q1955 1 q1956 +q956 0 q957 +q1956 1 q1957 +q957 0 q958 +q1957 1 q1958 +q958 0 q959 +q1958 1 q1959 +q959 0 q960 +q1959 1 q1960 +q960 0 q961 +q1960 1 q1961 +q961 0 q962 +q1961 1 q1962 +q962 0 q963 +q1962 1 q1963 +q963 0 q964 +q1963 1 q1964 +q964 0 q965 +q1964 1 q1965 +q965 0 q966 +q1965 1 q1966 +q966 0 q967 +q1966 1 q1967 +q967 0 q968 +q1967 1 q1968 +q968 0 q969 +q1968 1 q1969 +q969 0 q970 +q1969 1 q1970 +q970 0 q971 +q1970 1 q1971 +q971 0 q972 +q1971 1 q1972 +q972 0 q973 +q1972 1 q1973 +q973 0 q974 +q1973 1 q1974 +q974 0 q975 +q1974 1 q1975 +q975 0 q976 +q1975 1 q1976 +q976 0 q977 +q1976 1 q1977 +q977 0 q978 +q1977 1 q1978 +q978 0 q979 +q1978 1 q1979 +q979 0 q980 +q1979 1 q1980 +q980 0 q981 +q1980 1 q1981 +q981 0 q982 +q1981 1 q1982 +q982 0 q983 +q1982 1 q1983 +q983 0 q984 +q1983 1 q1984 +q984 0 q985 +q1984 1 q1985 +q985 0 q986 +q1985 1 q1986 +q986 0 q987 +q1986 1 q1987 +q987 0 q988 +q1987 1 q1988 +q988 0 q989 +q1988 1 q1989 +q989 0 q990 +q1989 1 q1990 +q990 0 q991 +q1990 1 q1991 +q991 0 q992 +q1991 1 q1992 +q992 0 q993 +q1992 1 q1993 +q993 0 q994 +q1993 1 q1994 +q994 0 q995 +q1994 1 q1995 +q995 0 q996 +q1995 1 q1996 +q996 0 q997 +q1996 1 q1997 +q997 0 q998 +q1997 1 q1998 +q998 0 q999 +q1998 1 q1999 +q999 0 q1000 +q1999 1 q2000 +q1 1 q2000 +q2 1 q1999 +q3 1 q1998 +q4 1 q1997 +q5 1 q1996 +q6 1 q1995 +q7 1 q1994 +q8 1 q1993 +q9 1 q1992 +q10 1 q1991 +q11 1 q1990 +q12 1 q1989 +q13 1 q1988 +q14 1 q1987 +q15 1 q1986 +q16 1 q1985 +q17 1 q1984 +q18 1 q1983 +q19 1 q1982 +q20 1 q1981 +q21 1 q1980 +q22 1 q1979 +q23 1 q1978 +q24 1 q1977 +q25 1 q1976 +q26 1 q1975 +q27 1 q1974 +q28 1 q1973 +q29 1 q1972 +q30 1 q1971 +q31 1 q1970 +q32 1 q1969 +q33 1 q1968 +q34 1 q1967 +q35 1 q1966 +q36 1 q1965 +q37 1 q1964 +q38 1 q1963 +q39 1 q1962 +q40 1 q1961 +q41 1 q1960 +q42 1 q1959 +q43 1 q1958 +q44 1 q1957 +q45 1 q1956 +q46 1 q1955 +q47 1 q1954 +q48 1 q1953 +q49 1 q1952 +q50 1 q1951 +q51 1 q1950 +q52 1 q1949 +q53 1 q1948 +q54 1 q1947 +q55 1 q1946 +q56 1 q1945 +q57 1 q1944 +q58 1 q1943 +q59 1 q1942 +q60 1 q1941 +q61 1 q1940 +q62 1 q1939 +q63 1 q1938 +q64 1 q1937 +q65 1 q1936 +q66 1 q1935 +q67 1 q1934 +q68 1 q1933 +q69 1 q1932 +q70 1 q1931 +q71 1 q1930 +q72 1 q1929 +q73 1 q1928 +q74 1 q1927 +q75 1 q1926 +q76 1 q1925 +q77 1 q1924 +q78 1 q1923 +q79 1 q1922 +q80 1 q1921 +q81 1 q1920 +q82 1 q1919 +q83 1 q1918 +q84 1 q1917 +q85 1 q1916 +q86 1 q1915 +q87 1 q1914 +q88 1 q1913 +q89 1 q1912 +q90 1 q1911 +q91 1 q1910 +q92 1 q1909 +q93 1 q1908 +q94 1 q1907 +q95 1 q1906 +q96 1 q1905 +q97 1 q1904 +q98 1 q1903 +q99 1 q1902 +q100 1 q1901 +q101 1 q1900 +q102 1 q1899 +q103 1 q1898 +q104 1 q1897 +q105 1 q1896 +q106 1 q1895 +q107 1 q1894 +q108 1 q1893 +q109 1 q1892 +q110 1 q1891 +q111 1 q1890 +q112 1 q1889 +q113 1 q1888 +q114 1 q1887 +q115 1 q1886 +q116 1 q1885 +q117 1 q1884 +q118 1 q1883 +q119 1 q1882 +q120 1 q1881 +q121 1 q1880 +q122 1 q1879 +q123 1 q1878 +q124 1 q1877 +q125 1 q1876 +q126 1 q1875 +q127 1 q1874 +q128 1 q1873 +q129 1 q1872 +q130 1 q1871 +q131 1 q1870 +q132 1 q1869 +q133 1 q1868 +q134 1 q1867 +q135 1 q1866 +q136 1 q1865 +q137 1 q1864 +q138 1 q1863 +q139 1 q1862 +q140 1 q1861 +q141 1 q1860 +q142 1 q1859 +q143 1 q1858 +q144 1 q1857 +q145 1 q1856 +q146 1 q1855 +q147 1 q1854 +q148 1 q1853 +q149 1 q1852 +q150 1 q1851 +q151 1 q1850 +q152 1 q1849 +q153 1 q1848 +q154 1 q1847 +q155 1 q1846 +q156 1 q1845 +q157 1 q1844 +q158 1 q1843 +q159 1 q1842 +q160 1 q1841 +q161 1 q1840 +q162 1 q1839 +q163 1 q1838 +q164 1 q1837 +q165 1 q1836 +q166 1 q1835 +q167 1 q1834 +q168 1 q1833 +q169 1 q1832 +q170 1 q1831 +q171 1 q1830 +q172 1 q1829 +q173 1 q1828 +q174 1 q1827 +q175 1 q1826 +q176 1 q1825 +q177 1 q1824 +q178 1 q1823 +q179 1 q1822 +q180 1 q1821 +q181 1 q1820 +q182 1 q1819 +q183 1 q1818 +q184 1 q1817 +q185 1 q1816 +q186 1 q1815 +q187 1 q1814 +q188 1 q1813 +q189 1 q1812 +q190 1 q1811 +q191 1 q1810 +q192 1 q1809 +q193 1 q1808 +q194 1 q1807 +q195 1 q1806 +q196 1 q1805 +q197 1 q1804 +q198 1 q1803 +q199 1 q1802 +q200 1 q1801 +q201 1 q1800 +q202 1 q1799 +q203 1 q1798 +q204 1 q1797 +q205 1 q1796 +q206 1 q1795 +q207 1 q1794 +q208 1 q1793 +q209 1 q1792 +q210 1 q1791 +q211 1 q1790 +q212 1 q1789 +q213 1 q1788 +q214 1 q1787 +q215 1 q1786 +q216 1 q1785 +q217 1 q1784 +q218 1 q1783 +q219 1 q1782 +q220 1 q1781 +q221 1 q1780 +q222 1 q1779 +q223 1 q1778 +q224 1 q1777 +q225 1 q1776 +q226 1 q1775 +q227 1 q1774 +q228 1 q1773 +q229 1 q1772 +q230 1 q1771 +q231 1 q1770 +q232 1 q1769 +q233 1 q1768 +q234 1 q1767 +q235 1 q1766 +q236 1 q1765 +q237 1 q1764 +q238 1 q1763 +q239 1 q1762 +q240 1 q1761 +q241 1 q1760 +q242 1 q1759 +q243 1 q1758 +q244 1 q1757 +q245 1 q1756 +q246 1 q1755 +q247 1 q1754 +q248 1 q1753 +q249 1 q1752 +q250 1 q1751 +q251 1 q1750 +q252 1 q1749 +q253 1 q1748 +q254 1 q1747 +q255 1 q1746 +q256 1 q1745 +q257 1 q1744 +q258 1 q1743 +q259 1 q1742 +q260 1 q1741 +q261 1 q1740 +q262 1 q1739 +q263 1 q1738 +q264 1 q1737 +q265 1 q1736 +q266 1 q1735 +q267 1 q1734 +q268 1 q1733 +q269 1 q1732 +q270 1 q1731 +q271 1 q1730 +q272 1 q1729 +q273 1 q1728 +q274 1 q1727 +q275 1 q1726 +q276 1 q1725 +q277 1 q1724 +q278 1 q1723 +q279 1 q1722 +q280 1 q1721 +q281 1 q1720 +q282 1 q1719 +q283 1 q1718 +q284 1 q1717 +q285 1 q1716 +q286 1 q1715 +q287 1 q1714 +q288 1 q1713 +q289 1 q1712 +q290 1 q1711 +q291 1 q1710 +q292 1 q1709 +q293 1 q1708 +q294 1 q1707 +q295 1 q1706 +q296 1 q1705 +q297 1 q1704 +q298 1 q1703 +q299 1 q1702 +q300 1 q1701 +q301 1 q1700 +q302 1 q1699 +q303 1 q1698 +q304 1 q1697 +q305 1 q1696 +q306 1 q1695 +q307 1 q1694 +q308 1 q1693 +q309 1 q1692 +q310 1 q1691 +q311 1 q1690 +q312 1 q1689 +q313 1 q1688 +q314 1 q1687 +q315 1 q1686 +q316 1 q1685 +q317 1 q1684 +q318 1 q1683 +q319 1 q1682 +q320 1 q1681 +q321 1 q1680 +q322 1 q1679 +q323 1 q1678 +q324 1 q1677 +q325 1 q1676 +q326 1 q1675 +q327 1 q1674 +q328 1 q1673 +q329 1 q1672 +q330 1 q1671 +q331 1 q1670 +q332 1 q1669 +q333 1 q1668 +q334 1 q1667 +q335 1 q1666 +q336 1 q1665 +q337 1 q1664 +q338 1 q1663 +q339 1 q1662 +q340 1 q1661 +q341 1 q1660 +q342 1 q1659 +q343 1 q1658 +q344 1 q1657 +q345 1 q1656 +q346 1 q1655 +q347 1 q1654 +q348 1 q1653 +q349 1 q1652 +q350 1 q1651 +q351 1 q1650 +q352 1 q1649 +q353 1 q1648 +q354 1 q1647 +q355 1 q1646 +q356 1 q1645 +q357 1 q1644 +q358 1 q1643 +q359 1 q1642 +q360 1 q1641 +q361 1 q1640 +q362 1 q1639 +q363 1 q1638 +q364 1 q1637 +q365 1 q1636 +q366 1 q1635 +q367 1 q1634 +q368 1 q1633 +q369 1 q1632 +q370 1 q1631 +q371 1 q1630 +q372 1 q1629 +q373 1 q1628 +q374 1 q1627 +q375 1 q1626 +q376 1 q1625 +q377 1 q1624 +q378 1 q1623 +q379 1 q1622 +q380 1 q1621 +q381 1 q1620 +q382 1 q1619 +q383 1 q1618 +q384 1 q1617 +q385 1 q1616 +q386 1 q1615 +q387 1 q1614 +q388 1 q1613 +q389 1 q1612 +q390 1 q1611 +q391 1 q1610 +q392 1 q1609 +q393 1 q1608 +q394 1 q1607 +q395 1 q1606 +q396 1 q1605 +q397 1 q1604 +q398 1 q1603 +q399 1 q1602 +q400 1 q1601 +q401 1 q1600 +q402 1 q1599 +q403 1 q1598 +q404 1 q1597 +q405 1 q1596 +q406 1 q1595 +q407 1 q1594 +q408 1 q1593 +q409 1 q1592 +q410 1 q1591 +q411 1 q1590 +q412 1 q1589 +q413 1 q1588 +q414 1 q1587 +q415 1 q1586 +q416 1 q1585 +q417 1 q1584 +q418 1 q1583 +q419 1 q1582 +q420 1 q1581 +q421 1 q1580 +q422 1 q1579 +q423 1 q1578 +q424 1 q1577 +q425 1 q1576 +q426 1 q1575 +q427 1 q1574 +q428 1 q1573 +q429 1 q1572 +q430 1 q1571 +q431 1 q1570 +q432 1 q1569 +q433 1 q1568 +q434 1 q1567 +q435 1 q1566 +q436 1 q1565 +q437 1 q1564 +q438 1 q1563 +q439 1 q1562 +q440 1 q1561 +q441 1 q1560 +q442 1 q1559 +q443 1 q1558 +q444 1 q1557 +q445 1 q1556 +q446 1 q1555 +q447 1 q1554 +q448 1 q1553 +q449 1 q1552 +q450 1 q1551 +q451 1 q1550 +q452 1 q1549 +q453 1 q1548 +q454 1 q1547 +q455 1 q1546 +q456 1 q1545 +q457 1 q1544 +q458 1 q1543 +q459 1 q1542 +q460 1 q1541 +q461 1 q1540 +q462 1 q1539 +q463 1 q1538 +q464 1 q1537 +q465 1 q1536 +q466 1 q1535 +q467 1 q1534 +q468 1 q1533 +q469 1 q1532 +q470 1 q1531 +q471 1 q1530 +q472 1 q1529 +q473 1 q1528 +q474 1 q1527 +q475 1 q1526 +q476 1 q1525 +q477 1 q1524 +q478 1 q1523 +q479 1 q1522 +q480 1 q1521 +q481 1 q1520 +q482 1 q1519 +q483 1 q1518 +q484 1 q1517 +q485 1 q1516 +q486 1 q1515 +q487 1 q1514 +q488 1 q1513 +q489 1 q1512 +q490 1 q1511 +q491 1 q1510 +q492 1 q1509 +q493 1 q1508 +q494 1 q1507 +q495 1 q1506 +q496 1 q1505 +q497 1 q1504 +q498 1 q1503 +q499 1 q1502 +q500 1 q1501 +q501 1 q1500 +q502 1 q1499 +q503 1 q1498 +q504 1 q1497 +q505 1 q1496 +q506 1 q1495 +q507 1 q1494 +q508 1 q1493 +q509 1 q1492 +q510 1 q1491 +q511 1 q1490 +q512 1 q1489 +q513 1 q1488 +q514 1 q1487 +q515 1 q1486 +q516 1 q1485 +q517 1 q1484 +q518 1 q1483 +q519 1 q1482 +q520 1 q1481 +q521 1 q1480 +q522 1 q1479 +q523 1 q1478 +q524 1 q1477 +q525 1 q1476 +q526 1 q1475 +q527 1 q1474 +q528 1 q1473 +q529 1 q1472 +q530 1 q1471 +q531 1 q1470 +q532 1 q1469 +q533 1 q1468 +q534 1 q1467 +q535 1 q1466 +q536 1 q1465 +q537 1 q1464 +q538 1 q1463 +q539 1 q1462 +q540 1 q1461 +q541 1 q1460 +q542 1 q1459 +q543 1 q1458 +q544 1 q1457 +q545 1 q1456 +q546 1 q1455 +q547 1 q1454 +q548 1 q1453 +q549 1 q1452 +q550 1 q1451 +q551 1 q1450 +q552 1 q1449 +q553 1 q1448 +q554 1 q1447 +q555 1 q1446 +q556 1 q1445 +q557 1 q1444 +q558 1 q1443 +q559 1 q1442 +q560 1 q1441 +q561 1 q1440 +q562 1 q1439 +q563 1 q1438 +q564 1 q1437 +q565 1 q1436 +q566 1 q1435 +q567 1 q1434 +q568 1 q1433 +q569 1 q1432 +q570 1 q1431 +q571 1 q1430 +q572 1 q1429 +q573 1 q1428 +q574 1 q1427 +q575 1 q1426 +q576 1 q1425 +q577 1 q1424 +q578 1 q1423 +q579 1 q1422 +q580 1 q1421 +q581 1 q1420 +q582 1 q1419 +q583 1 q1418 +q584 1 q1417 +q585 1 q1416 +q586 1 q1415 +q587 1 q1414 +q588 1 q1413 +q589 1 q1412 +q590 1 q1411 +q591 1 q1410 +q592 1 q1409 +q593 1 q1408 +q594 1 q1407 +q595 1 q1406 +q596 1 q1405 +q597 1 q1404 +q598 1 q1403 +q599 1 q1402 +q600 1 q1401 +q601 1 q1400 +q602 1 q1399 +q603 1 q1398 +q604 1 q1397 +q605 1 q1396 +q606 1 q1395 +q607 1 q1394 +q608 1 q1393 +q609 1 q1392 +q610 1 q1391 +q611 1 q1390 +q612 1 q1389 +q613 1 q1388 +q614 1 q1387 +q615 1 q1386 +q616 1 q1385 +q617 1 q1384 +q618 1 q1383 +q619 1 q1382 +q620 1 q1381 +q621 1 q1380 +q622 1 q1379 +q623 1 q1378 +q624 1 q1377 +q625 1 q1376 +q626 1 q1375 +q627 1 q1374 +q628 1 q1373 +q629 1 q1372 +q630 1 q1371 +q631 1 q1370 +q632 1 q1369 +q633 1 q1368 +q634 1 q1367 +q635 1 q1366 +q636 1 q1365 +q637 1 q1364 +q638 1 q1363 +q639 1 q1362 +q640 1 q1361 +q641 1 q1360 +q642 1 q1359 +q643 1 q1358 +q644 1 q1357 +q645 1 q1356 +q646 1 q1355 +q647 1 q1354 +q648 1 q1353 +q649 1 q1352 +q650 1 q1351 +q651 1 q1350 +q652 1 q1349 +q653 1 q1348 +q654 1 q1347 +q655 1 q1346 +q656 1 q1345 +q657 1 q1344 +q658 1 q1343 +q659 1 q1342 +q660 1 q1341 +q661 1 q1340 +q662 1 q1339 +q663 1 q1338 +q664 1 q1337 +q665 1 q1336 +q666 1 q1335 +q667 1 q1334 +q668 1 q1333 +q669 1 q1332 +q670 1 q1331 +q671 1 q1330 +q672 1 q1329 +q673 1 q1328 +q674 1 q1327 +q675 1 q1326 +q676 1 q1325 +q677 1 q1324 +q678 1 q1323 +q679 1 q1322 +q680 1 q1321 +q681 1 q1320 +q682 1 q1319 +q683 1 q1318 +q684 1 q1317 +q685 1 q1316 +q686 1 q1315 +q687 1 q1314 +q688 1 q1313 +q689 1 q1312 +q690 1 q1311 +q691 1 q1310 +q692 1 q1309 +q693 1 q1308 +q694 1 q1307 +q695 1 q1306 +q696 1 q1305 +q697 1 q1304 +q698 1 q1303 +q699 1 q1302 +q700 1 q1301 +q701 1 q1300 +q702 1 q1299 +q703 1 q1298 +q704 1 q1297 +q705 1 q1296 +q706 1 q1295 +q707 1 q1294 +q708 1 q1293 +q709 1 q1292 +q710 1 q1291 +q711 1 q1290 +q712 1 q1289 +q713 1 q1288 +q714 1 q1287 +q715 1 q1286 +q716 1 q1285 +q717 1 q1284 +q718 1 q1283 +q719 1 q1282 +q720 1 q1281 +q721 1 q1280 +q722 1 q1279 +q723 1 q1278 +q724 1 q1277 +q725 1 q1276 +q726 1 q1275 +q727 1 q1274 +q728 1 q1273 +q729 1 q1272 +q730 1 q1271 +q731 1 q1270 +q732 1 q1269 +q733 1 q1268 +q734 1 q1267 +q735 1 q1266 +q736 1 q1265 +q737 1 q1264 +q738 1 q1263 +q739 1 q1262 +q740 1 q1261 +q741 1 q1260 +q742 1 q1259 +q743 1 q1258 +q744 1 q1257 +q745 1 q1256 +q746 1 q1255 +q747 1 q1254 +q748 1 q1253 +q749 1 q1252 +q750 1 q1251 +q751 1 q1250 +q752 1 q1249 +q753 1 q1248 +q754 1 q1247 +q755 1 q1246 +q756 1 q1245 +q757 1 q1244 +q758 1 q1243 +q759 1 q1242 +q760 1 q1241 +q761 1 q1240 +q762 1 q1239 +q763 1 q1238 +q764 1 q1237 +q765 1 q1236 +q766 1 q1235 +q767 1 q1234 +q768 1 q1233 +q769 1 q1232 +q770 1 q1231 +q771 1 q1230 +q772 1 q1229 +q773 1 q1228 +q774 1 q1227 +q775 1 q1226 +q776 1 q1225 +q777 1 q1224 +q778 1 q1223 +q779 1 q1222 +q780 1 q1221 +q781 1 q1220 +q782 1 q1219 +q783 1 q1218 +q784 1 q1217 +q785 1 q1216 +q786 1 q1215 +q787 1 q1214 +q788 1 q1213 +q789 1 q1212 +q790 1 q1211 +q791 1 q1210 +q792 1 q1209 +q793 1 q1208 +q794 1 q1207 +q795 1 q1206 +q796 1 q1205 +q797 1 q1204 +q798 1 q1203 +q799 1 q1202 +q800 1 q1201 +q801 1 q1200 +q802 1 q1199 +q803 1 q1198 +q804 1 q1197 +q805 1 q1196 +q806 1 q1195 +q807 1 q1194 +q808 1 q1193 +q809 1 q1192 +q810 1 q1191 +q811 1 q1190 +q812 1 q1189 +q813 1 q1188 +q814 1 q1187 +q815 1 q1186 +q816 1 q1185 +q817 1 q1184 +q818 1 q1183 +q819 1 q1182 +q820 1 q1181 +q821 1 q1180 +q822 1 q1179 +q823 1 q1178 +q824 1 q1177 +q825 1 q1176 +q826 1 q1175 +q827 1 q1174 +q828 1 q1173 +q829 1 q1172 +q830 1 q1171 +q831 1 q1170 +q832 1 q1169 +q833 1 q1168 +q834 1 q1167 +q835 1 q1166 +q836 1 q1165 +q837 1 q1164 +q838 1 q1163 +q839 1 q1162 +q840 1 q1161 +q841 1 q1160 +q842 1 q1159 +q843 1 q1158 +q844 1 q1157 +q845 1 q1156 +q846 1 q1155 +q847 1 q1154 +q848 1 q1153 +q849 1 q1152 +q850 1 q1151 +q851 1 q1150 +q852 1 q1149 +q853 1 q1148 +q854 1 q1147 +q855 1 q1146 +q856 1 q1145 +q857 1 q1144 +q858 1 q1143 +q859 1 q1142 +q860 1 q1141 +q861 1 q1140 +q862 1 q1139 +q863 1 q1138 +q864 1 q1137 +q865 1 q1136 +q866 1 q1135 +q867 1 q1134 +q868 1 q1133 +q869 1 q1132 +q870 1 q1131 +q871 1 q1130 +q872 1 q1129 +q873 1 q1128 +q874 1 q1127 +q875 1 q1126 +q876 1 q1125 +q877 1 q1124 +q878 1 q1123 +q879 1 q1122 +q880 1 q1121 +q881 1 q1120 +q882 1 q1119 +q883 1 q1118 +q884 1 q1117 +q885 1 q1116 +q886 1 q1115 +q887 1 q1114 +q888 1 q1113 +q889 1 q1112 +q890 1 q1111 +q891 1 q1110 +q892 1 q1109 +q893 1 q1108 +q894 1 q1107 +q895 1 q1106 +q896 1 q1105 +q897 1 q1104 +q898 1 q1103 +q899 1 q1102 +q900 1 q1101 +q901 1 q1100 +q902 1 q1099 +q903 1 q1098 +q904 1 q1097 +q905 1 q1096 +q906 1 q1095 +q907 1 q1094 +q908 1 q1093 +q909 1 q1092 +q910 1 q1091 +q911 1 q1090 +q912 1 q1089 +q913 1 q1088 +q914 1 q1087 +q915 1 q1086 +q916 1 q1085 +q917 1 q1084 +q918 1 q1083 +q919 1 q1082 +q920 1 q1081 +q921 1 q1080 +q922 1 q1079 +q923 1 q1078 +q924 1 q1077 +q925 1 q1076 +q926 1 q1075 +q927 1 q1074 +q928 1 q1073 +q929 1 q1072 +q930 1 q1071 +q931 1 q1070 +q932 1 q1069 +q933 1 q1068 +q934 1 q1067 +q935 1 q1066 +q936 1 q1065 +q937 1 q1064 +q938 1 q1063 +q939 1 q1062 +q940 1 q1061 +q941 1 q1060 +q942 1 q1059 +q943 1 q1058 +q944 1 q1057 +q945 1 q1056 +q946 1 q1055 +q947 1 q1054 +q948 1 q1053 +q949 1 q1052 +q950 1 q1051 +q951 1 q1050 +q952 1 q1049 +q953 1 q1048 +q954 1 q1047 +q955 1 q1046 +q956 1 q1045 +q957 1 q1044 +q958 1 q1043 +q959 1 q1042 +q960 1 q1041 +q961 1 q1040 +q962 1 q1039 +q963 1 q1038 +q964 1 q1037 +q965 1 q1036 +q966 1 q1035 +q967 1 q1034 +q968 1 q1033 +q969 1 q1032 +q970 1 q1031 +q971 1 q1030 +q972 1 q1029 +q973 1 q1028 +q974 1 q1027 +q975 1 q1026 +q976 1 q1025 +q977 1 q1024 +q978 1 q1023 +q979 1 q1022 +q980 1 q1021 +q981 1 q1020 +q982 1 q1019 +q983 1 q1018 +q984 1 q1017 +q985 1 q1016 +q986 1 q1015 +q987 1 q1014 +q988 1 q1013 +q989 1 q1012 +q990 1 q1011 +q991 1 q1010 +q992 1 q1009 +q993 1 q1008 +q994 1 q1007 +q995 1 q1006 +q996 1 q1005 +q997 1 q1004 +q998 1 q1003 +q999 1 q1002 diff --git a/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n2.mata b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n2.mata new file mode 100644 index 000000000..339791fb2 --- /dev/null +++ b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n2.mata @@ -0,0 +1,8 @@ +@NFA-explicit +%Initial q0 +%Final q4 +q0 0 q1 +q2 1 q3 +q1 0 q2 +q3 1 q4 +q1 1 q4 diff --git a/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n3.mata b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n3.mata new file mode 100644 index 000000000..a9d8ee645 --- /dev/null +++ b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n3.mata @@ -0,0 +1,11 @@ +@NFA-explicit +%Initial q0 +%Final q6 +q0 0 q1 +q3 1 q4 +q1 0 q2 +q4 1 q5 +q2 0 q3 +q5 1 q6 +q1 1 q6 +q2 1 q5 diff --git a/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n4.mata b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n4.mata new file mode 100644 index 000000000..19b310d5d --- /dev/null +++ b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n4.mata @@ -0,0 +1,14 @@ +@NFA-explicit +%Initial q0 +%Final q8 +q0 0 q1 +q4 1 q5 +q1 0 q2 +q5 1 q6 +q2 0 q3 +q6 1 q7 +q3 0 q4 +q7 1 q8 +q1 1 q8 +q2 1 q7 +q3 1 q6 diff --git a/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n5.mata b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n5.mata new file mode 100644 index 000000000..dd46ab49d --- /dev/null +++ b/tests-integration/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n5.mata @@ -0,0 +1,17 @@ +@NFA-explicit +%Initial q0 +%Final q10 +q0 0 q1 +q5 1 q6 +q1 0 q2 +q6 1 q7 +q2 0 q3 +q7 1 q8 +q3 0 q4 +q8 1 q9 +q4 0 q5 +q9 1 q10 +q1 1 q10 +q2 1 q9 +q3 1 q8 +q4 1 q7 diff --git a/tests-integration/cntnfa-bench/scripts/generate_anbn_nfa.py b/tests-integration/cntnfa-bench/scripts/generate_anbn_nfa.py new file mode 100644 index 000000000..357592829 --- /dev/null +++ b/tests-integration/cntnfa-bench/scripts/generate_anbn_nfa.py @@ -0,0 +1,37 @@ +import argparse + +def generate_anbn_nfa(n: int, output_path: str): + states = set() + transitions = [] + final_states = {f"q{n * 2}"} + + # add states + for i in range(0, n * 2): + states.add(f"q{i}") + + for i in range(0, n): + # add transitions with a + transitions.append(f"q{i} 0 q{i + 1}") + # add transitions with b + transitions.append(f"q{i + n} 1 q{i + n + 1}") + + if n > 1: + # add middle transitions with b + for i in range(0, n - 1): + transitions.append(f"q{i + 1} 1 q{n * 2 - i}") + + with open(output_path, "w") as file: + file.write("@NFA-explicit\n") + file.write("%Initial q0\n") + file.write("%Final " + " ".join(sorted(final_states)) + "\n") + + for transition in transitions: + file.write(transition + "\n") + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--n", type=int, required=True, help="Maximum n for a^nb^n") + parser.add_argument("--output", type=str, required=True, help="Output .nfa file path") + args = parser.parse_args() + + generate_anbn_nfa(args.n, args.output) diff --git a/tests-integration/cntnfa-bench/scripts/generate_input.py b/tests-integration/cntnfa-bench/scripts/generate_input.py new file mode 100644 index 000000000..d4d9643bd --- /dev/null +++ b/tests-integration/cntnfa-bench/scripts/generate_input.py @@ -0,0 +1,7 @@ +input_file_path = "../../inputs/double-large-sequence.input.in" +benchmark_subpath = "@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence" + +with open(input_file_path, "w") as f: + for n in range(1, 10001): + line = f"{benchmark_subpath}/nfa-0-{n}.mata;{benchmark_subpath}/cntnfa-0-{n}.mata" + f.write(line + "\n") diff --git a/tests-integration/cntnfa-bench/scripts/generate_zero_sequence.py b/tests-integration/cntnfa-bench/scripts/generate_zero_sequence.py new file mode 100644 index 000000000..36316bfd6 --- /dev/null +++ b/tests-integration/cntnfa-bench/scripts/generate_zero_sequence.py @@ -0,0 +1,36 @@ +import os + +output_dir = "../benchmarks/large_sequence" +os.makedirs(output_dir, exist_ok=True) + +def generate_nfa(n): + lines = ["@NFA-explicit", "%Initial q0", f"%Final q{n}"] + for i in range(n): + lines.append(f"q{i} 0 q{i+1}") + return "\n".join(lines) + +def generate_cntnfa(n): + lines = [ + "@CNTNFA-explicit", + "%States q0 q1", + "%Alphabet-auto", + "%Initial q0", + "%Final q1", + "%Registers c0", + f"q0 0 (+ c0 1) q0", + f"q0 0 (= c0 {n - 1}) q1" + ] + return "\n".join(lines) + +for n in range(1, 10001): + nfa_text = generate_nfa(n) + cntnfa_text = generate_cntnfa(n) + + nfa_path = os.path.join(output_dir, f"nfa-0-{n}.mata") + cntnfa_path = os.path.join(output_dir, f"cntnfa-0-{n}.mata") + + with open(nfa_path, 'w') as f: + f.write(nfa_text + "\n") + + with open(cntnfa_path, 'w') as f: + f.write(cntnfa_text + "\n") diff --git a/tests-integration/inputs/double-anbn.input.in b/tests-integration/inputs/double-anbn.input.in new file mode 100644 index 000000000..2f8b35d3a --- /dev/null +++ b/tests-integration/inputs/double-anbn.input.in @@ -0,0 +1,6 @@ +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n2.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n3.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n4.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n5.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata diff --git a/tests-integration/inputs/double-large-sequence.input.in b/tests-integration/inputs/double-large-sequence.input.in new file mode 100644 index 000000000..d205235e5 --- /dev/null +++ b/tests-integration/inputs/double-large-sequence.input.in @@ -0,0 +1,10000 @@ +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-10.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-10.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-11.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-11.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-12.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-12.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-13.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-13.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-14.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-14.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-15.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-15.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-16.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-16.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-17.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-17.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-18.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-18.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-19.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-19.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-20.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-20.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-21.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-21.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-22.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-22.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-23.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-23.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-24.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-24.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-25.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-25.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-26.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-26.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-27.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-27.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-28.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-28.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-29.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-29.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-30.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-30.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-31.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-31.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-32.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-32.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-33.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-33.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-34.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-34.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-35.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-35.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-36.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-36.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-37.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-37.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-38.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-38.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-39.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-39.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-40.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-40.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-41.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-41.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-42.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-42.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-43.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-43.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-44.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-44.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-45.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-45.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-46.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-46.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-47.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-47.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-48.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-48.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-49.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-49.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-50.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-50.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-51.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-51.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-52.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-52.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-53.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-53.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-54.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-54.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-55.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-55.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-56.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-56.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-57.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-57.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-58.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-58.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-59.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-59.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-60.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-60.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-61.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-61.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-62.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-62.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-63.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-63.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-64.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-64.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-65.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-65.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-66.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-66.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-67.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-67.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-68.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-68.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-69.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-69.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-70.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-70.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-71.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-71.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-72.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-72.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-73.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-73.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-74.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-74.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-75.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-75.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-76.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-76.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-77.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-77.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-78.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-78.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-79.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-79.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-80.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-80.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-81.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-81.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-82.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-82.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-83.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-83.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-84.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-84.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-85.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-85.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-86.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-86.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-87.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-87.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-88.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-88.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-89.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-89.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-90.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-90.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-91.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-91.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-92.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-92.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-93.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-93.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-94.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-94.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-95.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-95.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-96.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-96.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-97.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-97.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-98.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-98.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-99.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-99.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1000.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1001.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1001.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1002.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1002.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1003.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1003.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1004.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1004.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1005.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1005.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1006.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1006.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1007.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1007.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1008.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1008.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1009.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1009.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1010.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1010.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1011.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1011.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1012.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1012.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1013.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1013.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1014.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1014.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1015.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1015.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1016.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1016.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1017.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1017.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1018.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1018.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1019.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1019.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1020.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1020.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1021.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1021.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1022.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1022.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1023.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1023.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1024.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1024.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1025.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1025.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1026.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1026.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1027.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1027.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1028.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1028.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1029.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1029.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1030.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1030.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1031.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1031.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1032.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1032.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1033.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1033.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1034.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1034.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1035.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1035.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1036.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1036.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1037.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1037.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1038.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1038.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1039.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1039.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1040.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1040.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1041.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1041.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1042.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1042.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1043.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1043.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1044.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1044.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1045.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1045.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1046.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1046.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1047.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1047.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1048.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1048.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1049.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1049.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1050.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1050.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1051.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1051.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1052.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1052.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1053.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1053.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1054.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1054.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1055.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1055.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1056.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1056.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1057.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1057.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1058.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1058.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1059.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1059.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1060.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1060.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1061.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1061.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1062.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1062.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1063.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1063.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1064.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1064.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1065.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1065.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1066.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1066.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1067.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1067.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1068.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1068.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1069.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1069.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1070.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1070.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1071.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1071.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1072.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1072.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1073.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1073.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1074.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1074.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1075.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1075.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1076.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1076.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1077.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1077.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1078.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1078.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1079.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1079.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1080.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1080.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1081.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1081.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1082.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1082.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1083.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1083.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1084.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1084.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1085.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1085.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1086.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1086.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1087.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1087.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1088.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1088.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1089.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1089.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1090.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1090.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1091.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1091.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1092.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1092.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1093.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1093.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1094.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1094.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1095.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1095.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1096.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1096.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1097.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1097.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1098.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1098.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1099.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1099.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-1999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-1999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2000.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2001.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2001.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2002.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2002.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2003.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2003.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2004.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2004.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2005.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2005.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2006.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2006.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2007.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2007.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2008.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2008.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2009.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2009.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2010.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2010.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2011.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2011.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2012.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2012.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2013.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2013.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2014.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2014.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2015.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2015.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2016.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2016.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2017.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2017.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2018.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2018.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2019.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2019.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2020.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2020.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2021.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2021.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2022.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2022.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2023.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2023.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2024.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2024.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2025.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2025.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2026.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2026.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2027.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2027.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2028.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2028.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2029.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2029.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2030.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2030.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2031.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2031.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2032.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2032.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2033.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2033.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2034.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2034.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2035.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2035.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2036.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2036.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2037.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2037.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2038.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2038.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2039.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2039.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2040.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2040.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2041.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2041.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2042.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2042.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2043.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2043.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2044.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2044.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2045.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2045.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2046.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2046.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2047.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2047.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2048.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2048.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2049.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2049.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2050.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2050.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2051.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2051.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2052.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2052.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2053.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2053.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2054.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2054.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2055.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2055.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2056.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2056.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2057.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2057.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2058.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2058.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2059.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2059.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2060.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2060.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2061.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2061.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2062.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2062.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2063.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2063.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2064.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2064.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2065.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2065.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2066.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2066.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2067.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2067.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2068.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2068.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2069.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2069.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2070.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2070.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2071.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2071.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2072.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2072.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2073.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2073.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2074.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2074.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2075.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2075.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2076.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2076.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2077.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2077.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2078.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2078.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2079.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2079.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2080.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2080.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2081.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2081.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2082.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2082.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2083.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2083.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2084.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2084.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2085.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2085.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2086.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2086.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2087.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2087.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2088.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2088.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2089.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2089.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2090.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2090.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2091.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2091.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2092.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2092.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2093.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2093.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2094.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2094.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2095.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2095.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2096.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2096.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2097.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2097.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2098.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2098.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2099.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2099.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-2999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-2999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3000.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3001.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3001.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3002.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3002.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3003.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3003.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3004.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3004.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3005.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3005.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3006.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3006.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3007.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3007.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3008.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3008.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3009.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3009.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3010.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3010.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3011.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3011.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3012.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3012.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3013.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3013.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3014.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3014.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3015.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3015.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3016.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3016.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3017.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3017.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3018.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3018.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3019.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3019.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3020.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3020.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3021.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3021.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3022.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3022.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3023.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3023.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3024.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3024.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3025.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3025.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3026.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3026.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3027.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3027.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3028.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3028.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3029.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3029.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3030.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3030.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3031.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3031.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3032.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3032.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3033.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3033.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3034.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3034.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3035.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3035.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3036.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3036.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3037.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3037.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3038.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3038.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3039.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3039.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3040.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3040.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3041.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3041.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3042.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3042.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3043.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3043.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3044.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3044.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3045.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3045.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3046.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3046.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3047.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3047.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3048.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3048.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3049.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3049.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3050.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3050.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3051.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3051.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3052.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3052.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3053.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3053.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3054.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3054.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3055.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3055.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3056.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3056.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3057.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3057.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3058.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3058.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3059.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3059.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3060.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3060.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3061.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3061.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3062.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3062.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3063.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3063.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3064.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3064.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3065.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3065.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3066.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3066.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3067.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3067.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3068.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3068.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3069.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3069.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3070.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3070.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3071.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3071.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3072.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3072.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3073.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3073.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3074.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3074.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3075.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3075.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3076.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3076.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3077.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3077.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3078.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3078.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3079.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3079.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3080.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3080.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3081.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3081.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3082.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3082.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3083.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3083.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3084.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3084.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3085.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3085.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3086.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3086.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3087.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3087.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3088.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3088.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3089.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3089.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3090.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3090.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3091.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3091.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3092.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3092.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3093.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3093.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3094.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3094.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3095.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3095.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3096.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3096.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3097.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3097.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3098.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3098.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3099.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3099.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-3999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-3999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4000.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4001.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4001.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4002.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4002.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4003.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4003.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4004.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4004.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4005.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4005.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4006.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4006.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4007.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4007.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4008.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4008.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4009.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4009.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4010.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4010.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4011.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4011.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4012.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4012.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4013.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4013.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4014.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4014.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4015.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4015.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4016.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4016.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4017.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4017.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4018.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4018.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4019.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4019.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4020.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4020.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4021.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4021.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4022.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4022.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4023.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4023.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4024.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4024.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4025.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4025.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4026.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4026.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4027.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4027.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4028.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4028.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4029.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4029.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4030.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4030.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4031.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4031.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4032.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4032.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4033.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4033.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4034.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4034.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4035.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4035.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4036.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4036.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4037.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4037.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4038.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4038.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4039.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4039.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4040.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4040.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4041.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4041.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4042.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4042.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4043.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4043.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4044.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4044.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4045.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4045.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4046.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4046.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4047.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4047.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4048.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4048.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4049.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4049.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4050.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4050.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4051.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4051.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4052.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4052.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4053.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4053.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4054.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4054.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4055.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4055.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4056.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4056.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4057.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4057.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4058.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4058.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4059.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4059.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4060.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4060.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4061.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4061.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4062.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4062.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4063.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4063.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4064.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4064.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4065.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4065.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4066.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4066.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4067.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4067.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4068.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4068.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4069.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4069.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4070.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4070.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4071.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4071.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4072.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4072.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4073.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4073.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4074.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4074.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4075.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4075.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4076.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4076.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4077.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4077.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4078.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4078.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4079.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4079.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4080.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4080.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4081.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4081.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4082.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4082.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4083.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4083.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4084.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4084.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4085.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4085.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4086.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4086.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4087.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4087.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4088.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4088.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4089.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4089.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4090.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4090.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4091.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4091.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4092.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4092.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4093.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4093.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4094.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4094.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4095.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4095.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4096.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4096.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4097.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4097.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4098.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4098.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4099.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4099.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-4999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-4999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5000.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5001.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5001.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5002.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5002.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5003.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5003.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5004.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5004.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5005.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5005.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5006.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5006.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5007.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5007.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5008.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5008.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5009.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5009.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5010.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5010.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5011.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5011.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5012.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5012.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5013.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5013.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5014.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5014.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5015.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5015.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5016.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5016.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5017.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5017.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5018.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5018.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5019.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5019.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5020.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5020.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5021.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5021.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5022.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5022.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5023.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5023.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5024.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5024.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5025.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5025.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5026.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5026.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5027.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5027.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5028.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5028.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5029.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5029.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5030.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5030.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5031.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5031.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5032.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5032.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5033.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5033.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5034.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5034.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5035.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5035.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5036.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5036.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5037.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5037.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5038.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5038.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5039.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5039.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5040.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5040.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5041.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5041.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5042.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5042.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5043.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5043.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5044.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5044.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5045.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5045.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5046.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5046.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5047.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5047.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5048.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5048.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5049.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5049.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5050.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5050.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5051.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5051.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5052.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5052.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5053.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5053.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5054.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5054.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5055.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5055.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5056.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5056.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5057.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5057.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5058.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5058.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5059.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5059.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5060.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5060.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5061.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5061.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5062.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5062.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5063.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5063.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5064.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5064.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5065.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5065.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5066.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5066.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5067.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5067.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5068.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5068.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5069.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5069.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5070.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5070.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5071.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5071.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5072.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5072.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5073.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5073.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5074.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5074.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5075.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5075.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5076.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5076.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5077.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5077.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5078.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5078.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5079.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5079.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5080.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5080.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5081.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5081.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5082.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5082.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5083.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5083.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5084.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5084.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5085.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5085.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5086.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5086.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5087.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5087.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5088.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5088.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5089.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5089.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5090.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5090.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5091.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5091.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5092.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5092.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5093.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5093.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5094.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5094.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5095.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5095.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5096.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5096.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5097.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5097.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5098.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5098.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5099.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5099.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-5999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-5999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6000.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6001.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6001.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6002.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6002.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6003.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6003.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6004.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6004.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6005.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6005.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6006.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6006.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6007.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6007.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6008.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6008.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6009.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6009.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6010.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6010.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6011.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6011.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6012.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6012.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6013.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6013.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6014.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6014.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6015.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6015.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6016.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6016.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6017.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6017.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6018.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6018.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6019.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6019.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6020.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6020.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6021.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6021.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6022.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6022.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6023.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6023.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6024.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6024.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6025.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6025.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6026.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6026.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6027.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6027.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6028.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6028.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6029.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6029.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6030.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6030.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6031.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6031.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6032.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6032.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6033.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6033.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6034.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6034.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6035.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6035.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6036.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6036.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6037.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6037.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6038.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6038.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6039.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6039.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6040.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6040.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6041.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6041.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6042.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6042.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6043.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6043.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6044.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6044.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6045.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6045.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6046.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6046.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6047.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6047.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6048.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6048.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6049.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6049.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6050.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6050.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6051.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6051.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6052.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6052.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6053.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6053.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6054.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6054.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6055.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6055.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6056.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6056.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6057.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6057.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6058.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6058.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6059.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6059.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6060.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6060.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6061.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6061.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6062.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6062.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6063.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6063.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6064.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6064.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6065.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6065.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6066.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6066.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6067.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6067.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6068.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6068.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6069.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6069.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6070.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6070.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6071.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6071.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6072.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6072.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6073.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6073.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6074.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6074.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6075.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6075.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6076.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6076.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6077.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6077.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6078.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6078.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6079.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6079.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6080.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6080.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6081.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6081.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6082.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6082.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6083.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6083.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6084.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6084.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6085.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6085.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6086.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6086.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6087.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6087.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6088.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6088.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6089.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6089.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6090.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6090.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6091.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6091.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6092.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6092.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6093.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6093.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6094.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6094.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6095.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6095.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6096.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6096.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6097.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6097.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6098.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6098.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6099.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6099.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-6999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-6999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7000.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7001.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7001.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7002.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7002.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7003.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7003.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7004.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7004.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7005.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7005.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7006.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7006.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7007.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7007.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7008.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7008.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7009.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7009.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7010.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7010.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7011.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7011.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7012.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7012.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7013.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7013.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7014.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7014.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7015.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7015.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7016.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7016.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7017.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7017.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7018.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7018.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7019.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7019.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7020.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7020.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7021.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7021.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7022.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7022.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7023.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7023.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7024.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7024.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7025.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7025.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7026.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7026.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7027.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7027.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7028.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7028.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7029.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7029.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7030.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7030.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7031.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7031.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7032.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7032.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7033.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7033.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7034.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7034.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7035.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7035.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7036.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7036.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7037.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7037.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7038.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7038.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7039.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7039.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7040.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7040.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7041.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7041.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7042.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7042.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7043.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7043.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7044.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7044.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7045.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7045.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7046.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7046.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7047.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7047.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7048.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7048.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7049.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7049.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7050.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7050.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7051.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7051.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7052.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7052.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7053.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7053.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7054.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7054.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7055.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7055.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7056.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7056.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7057.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7057.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7058.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7058.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7059.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7059.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7060.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7060.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7061.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7061.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7062.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7062.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7063.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7063.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7064.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7064.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7065.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7065.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7066.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7066.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7067.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7067.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7068.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7068.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7069.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7069.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7070.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7070.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7071.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7071.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7072.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7072.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7073.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7073.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7074.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7074.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7075.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7075.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7076.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7076.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7077.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7077.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7078.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7078.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7079.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7079.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7080.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7080.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7081.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7081.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7082.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7082.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7083.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7083.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7084.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7084.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7085.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7085.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7086.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7086.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7087.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7087.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7088.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7088.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7089.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7089.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7090.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7090.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7091.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7091.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7092.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7092.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7093.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7093.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7094.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7094.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7095.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7095.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7096.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7096.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7097.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7097.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7098.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7098.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7099.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7099.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-7999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-7999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8000.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8001.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8001.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8002.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8002.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8003.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8003.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8004.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8004.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8005.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8005.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8006.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8006.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8007.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8007.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8008.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8008.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8009.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8009.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8010.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8010.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8011.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8011.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8012.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8012.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8013.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8013.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8014.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8014.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8015.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8015.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8016.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8016.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8017.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8017.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8018.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8018.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8019.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8019.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8020.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8020.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8021.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8021.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8022.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8022.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8023.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8023.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8024.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8024.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8025.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8025.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8026.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8026.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8027.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8027.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8028.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8028.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8029.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8029.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8030.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8030.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8031.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8031.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8032.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8032.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8033.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8033.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8034.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8034.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8035.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8035.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8036.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8036.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8037.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8037.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8038.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8038.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8039.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8039.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8040.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8040.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8041.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8041.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8042.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8042.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8043.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8043.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8044.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8044.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8045.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8045.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8046.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8046.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8047.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8047.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8048.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8048.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8049.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8049.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8050.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8050.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8051.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8051.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8052.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8052.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8053.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8053.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8054.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8054.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8055.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8055.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8056.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8056.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8057.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8057.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8058.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8058.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8059.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8059.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8060.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8060.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8061.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8061.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8062.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8062.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8063.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8063.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8064.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8064.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8065.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8065.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8066.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8066.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8067.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8067.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8068.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8068.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8069.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8069.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8070.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8070.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8071.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8071.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8072.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8072.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8073.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8073.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8074.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8074.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8075.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8075.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8076.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8076.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8077.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8077.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8078.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8078.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8079.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8079.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8080.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8080.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8081.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8081.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8082.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8082.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8083.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8083.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8084.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8084.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8085.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8085.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8086.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8086.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8087.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8087.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8088.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8088.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8089.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8089.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8090.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8090.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8091.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8091.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8092.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8092.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8093.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8093.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8094.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8094.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8095.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8095.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8096.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8096.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8097.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8097.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8098.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8098.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8099.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8099.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-8999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-8999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9000.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9001.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9001.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9002.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9002.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9003.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9003.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9004.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9004.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9005.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9005.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9006.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9006.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9007.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9007.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9008.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9008.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9009.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9009.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9010.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9010.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9011.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9011.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9012.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9012.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9013.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9013.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9014.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9014.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9015.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9015.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9016.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9016.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9017.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9017.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9018.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9018.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9019.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9019.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9020.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9020.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9021.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9021.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9022.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9022.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9023.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9023.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9024.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9024.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9025.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9025.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9026.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9026.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9027.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9027.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9028.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9028.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9029.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9029.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9030.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9030.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9031.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9031.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9032.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9032.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9033.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9033.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9034.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9034.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9035.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9035.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9036.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9036.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9037.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9037.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9038.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9038.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9039.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9039.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9040.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9040.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9041.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9041.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9042.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9042.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9043.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9043.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9044.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9044.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9045.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9045.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9046.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9046.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9047.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9047.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9048.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9048.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9049.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9049.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9050.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9050.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9051.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9051.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9052.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9052.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9053.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9053.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9054.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9054.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9055.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9055.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9056.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9056.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9057.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9057.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9058.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9058.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9059.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9059.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9060.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9060.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9061.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9061.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9062.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9062.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9063.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9063.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9064.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9064.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9065.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9065.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9066.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9066.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9067.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9067.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9068.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9068.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9069.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9069.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9070.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9070.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9071.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9071.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9072.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9072.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9073.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9073.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9074.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9074.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9075.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9075.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9076.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9076.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9077.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9077.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9078.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9078.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9079.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9079.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9080.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9080.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9081.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9081.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9082.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9082.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9083.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9083.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9084.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9084.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9085.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9085.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9086.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9086.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9087.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9087.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9088.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9088.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9089.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9089.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9090.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9090.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9091.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9091.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9092.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9092.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9093.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9093.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9094.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9094.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9095.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9095.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9096.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9096.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9097.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9097.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9098.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9098.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9099.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9099.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9100.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9100.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9101.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9101.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9102.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9102.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9103.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9103.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9104.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9104.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9105.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9105.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9106.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9106.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9107.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9107.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9108.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9108.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9109.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9109.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9110.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9110.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9111.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9111.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9112.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9112.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9113.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9113.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9114.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9114.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9115.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9115.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9116.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9116.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9117.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9117.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9118.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9118.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9119.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9119.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9120.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9120.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9121.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9121.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9122.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9122.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9123.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9123.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9124.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9124.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9125.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9125.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9126.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9126.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9127.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9127.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9128.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9128.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9129.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9129.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9130.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9130.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9131.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9131.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9132.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9132.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9133.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9133.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9134.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9134.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9135.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9135.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9136.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9136.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9137.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9137.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9138.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9138.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9139.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9139.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9140.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9140.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9141.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9141.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9142.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9142.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9143.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9143.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9144.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9144.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9145.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9145.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9146.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9146.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9147.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9147.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9148.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9148.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9149.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9149.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9150.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9150.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9151.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9151.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9152.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9152.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9153.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9153.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9154.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9154.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9155.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9155.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9156.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9156.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9157.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9157.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9158.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9158.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9159.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9159.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9160.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9160.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9161.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9161.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9162.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9162.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9163.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9163.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9164.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9164.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9165.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9165.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9166.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9166.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9167.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9167.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9168.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9168.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9169.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9169.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9170.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9170.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9171.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9171.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9172.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9172.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9173.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9173.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9174.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9174.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9175.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9175.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9176.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9176.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9177.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9177.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9178.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9178.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9179.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9179.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9180.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9180.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9181.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9181.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9182.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9182.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9183.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9183.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9184.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9184.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9185.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9185.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9186.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9186.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9187.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9187.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9188.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9188.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9189.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9189.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9190.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9190.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9191.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9191.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9192.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9192.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9193.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9193.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9194.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9194.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9195.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9195.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9196.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9196.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9197.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9197.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9198.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9198.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9199.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9199.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9200.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9200.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9201.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9201.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9202.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9202.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9203.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9203.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9204.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9204.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9205.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9205.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9206.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9206.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9207.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9207.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9208.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9208.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9209.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9209.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9210.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9210.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9211.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9211.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9212.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9212.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9213.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9213.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9214.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9214.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9215.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9215.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9216.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9216.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9217.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9217.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9218.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9218.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9219.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9219.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9220.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9220.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9221.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9221.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9222.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9222.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9223.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9223.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9224.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9224.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9225.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9225.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9226.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9226.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9227.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9227.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9228.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9228.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9229.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9229.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9230.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9230.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9231.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9231.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9232.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9232.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9233.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9233.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9234.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9234.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9235.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9235.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9236.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9236.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9237.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9237.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9238.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9238.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9239.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9239.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9240.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9240.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9241.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9241.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9242.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9242.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9243.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9243.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9244.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9244.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9245.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9245.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9246.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9246.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9247.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9247.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9248.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9248.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9249.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9249.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9250.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9250.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9251.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9251.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9252.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9252.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9253.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9253.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9254.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9254.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9255.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9255.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9256.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9256.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9257.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9257.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9258.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9258.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9259.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9259.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9260.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9260.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9261.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9261.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9262.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9262.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9263.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9263.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9264.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9264.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9265.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9265.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9266.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9266.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9267.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9267.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9268.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9268.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9269.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9269.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9270.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9270.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9271.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9271.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9272.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9272.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9273.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9273.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9274.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9274.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9275.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9275.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9276.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9276.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9277.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9277.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9278.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9278.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9279.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9279.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9280.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9280.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9281.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9281.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9282.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9282.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9283.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9283.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9284.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9284.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9285.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9285.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9286.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9286.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9287.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9287.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9288.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9288.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9289.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9289.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9290.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9290.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9291.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9291.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9292.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9292.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9293.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9293.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9294.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9294.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9295.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9295.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9296.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9296.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9297.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9297.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9298.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9298.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9299.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9299.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9300.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9300.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9301.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9301.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9302.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9302.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9303.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9303.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9304.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9304.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9305.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9305.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9306.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9306.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9307.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9307.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9308.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9308.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9309.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9309.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9310.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9310.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9311.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9311.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9312.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9312.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9313.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9313.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9314.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9314.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9315.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9315.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9316.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9316.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9317.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9317.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9318.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9318.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9319.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9319.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9320.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9320.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9321.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9321.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9322.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9322.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9323.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9323.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9324.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9324.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9325.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9325.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9326.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9326.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9327.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9327.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9328.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9328.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9329.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9329.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9330.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9330.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9331.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9331.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9332.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9332.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9333.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9333.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9334.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9334.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9335.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9335.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9336.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9336.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9337.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9337.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9338.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9338.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9339.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9339.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9340.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9340.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9341.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9341.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9342.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9342.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9343.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9343.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9344.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9344.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9345.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9345.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9346.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9346.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9347.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9347.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9348.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9348.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9349.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9349.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9350.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9350.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9351.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9351.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9352.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9352.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9353.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9353.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9354.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9354.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9355.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9355.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9356.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9356.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9357.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9357.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9358.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9358.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9359.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9359.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9360.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9360.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9361.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9361.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9362.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9362.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9363.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9363.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9364.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9364.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9365.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9365.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9366.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9366.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9367.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9367.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9368.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9368.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9369.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9369.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9370.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9370.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9371.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9371.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9372.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9372.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9373.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9373.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9374.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9374.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9375.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9375.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9376.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9376.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9377.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9377.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9378.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9378.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9379.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9379.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9380.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9380.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9381.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9381.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9382.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9382.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9383.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9383.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9384.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9384.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9385.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9385.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9386.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9386.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9387.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9387.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9388.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9388.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9389.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9389.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9390.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9390.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9391.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9391.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9392.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9392.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9393.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9393.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9394.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9394.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9395.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9395.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9396.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9396.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9397.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9397.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9398.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9398.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9399.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9399.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9400.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9400.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9401.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9401.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9402.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9402.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9403.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9403.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9404.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9404.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9405.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9405.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9406.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9406.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9407.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9407.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9408.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9408.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9409.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9409.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9410.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9410.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9411.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9411.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9412.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9412.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9413.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9413.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9414.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9414.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9415.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9415.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9416.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9416.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9417.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9417.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9418.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9418.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9419.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9419.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9420.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9420.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9421.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9421.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9422.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9422.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9423.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9423.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9424.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9424.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9425.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9425.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9426.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9426.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9427.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9427.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9428.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9428.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9429.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9429.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9430.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9430.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9431.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9431.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9432.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9432.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9433.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9433.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9434.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9434.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9435.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9435.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9436.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9436.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9437.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9437.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9438.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9438.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9439.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9439.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9440.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9440.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9441.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9441.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9442.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9442.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9443.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9443.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9444.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9444.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9445.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9445.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9446.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9446.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9447.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9447.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9448.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9448.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9449.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9449.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9450.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9450.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9451.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9451.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9452.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9452.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9453.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9453.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9454.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9454.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9455.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9455.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9456.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9456.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9457.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9457.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9458.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9458.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9459.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9459.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9460.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9460.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9461.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9461.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9462.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9462.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9463.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9463.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9464.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9464.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9465.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9465.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9466.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9466.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9467.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9467.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9468.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9468.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9469.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9469.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9470.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9470.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9471.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9471.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9472.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9472.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9473.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9473.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9474.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9474.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9475.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9475.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9476.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9476.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9477.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9477.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9478.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9478.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9479.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9479.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9480.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9480.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9481.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9481.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9482.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9482.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9483.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9483.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9484.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9484.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9485.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9485.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9486.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9486.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9487.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9487.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9488.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9488.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9489.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9489.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9490.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9490.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9491.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9491.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9492.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9492.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9493.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9493.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9494.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9494.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9495.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9495.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9496.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9496.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9497.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9497.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9498.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9498.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9499.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9499.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9500.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9500.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9501.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9501.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9502.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9502.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9503.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9503.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9504.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9504.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9505.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9505.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9506.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9506.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9507.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9507.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9508.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9508.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9509.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9509.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9510.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9510.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9511.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9511.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9512.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9512.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9513.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9513.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9514.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9514.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9515.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9515.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9516.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9516.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9517.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9517.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9518.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9518.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9519.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9519.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9520.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9520.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9521.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9521.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9522.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9522.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9523.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9523.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9524.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9524.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9525.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9525.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9526.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9526.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9527.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9527.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9528.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9528.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9529.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9529.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9530.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9530.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9531.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9531.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9532.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9532.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9533.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9533.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9534.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9534.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9535.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9535.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9536.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9536.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9537.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9537.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9538.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9538.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9539.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9539.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9540.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9540.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9541.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9541.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9542.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9542.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9543.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9543.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9544.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9544.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9545.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9545.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9546.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9546.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9547.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9547.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9548.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9548.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9549.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9549.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9550.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9550.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9551.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9551.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9552.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9552.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9553.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9553.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9554.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9554.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9555.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9555.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9556.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9556.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9557.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9557.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9558.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9558.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9559.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9559.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9560.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9560.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9561.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9561.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9562.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9562.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9563.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9563.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9564.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9564.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9565.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9565.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9566.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9566.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9567.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9567.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9568.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9568.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9569.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9569.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9570.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9570.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9571.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9571.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9572.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9572.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9573.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9573.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9574.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9574.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9575.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9575.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9576.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9576.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9577.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9577.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9578.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9578.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9579.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9579.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9580.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9580.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9581.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9581.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9582.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9582.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9583.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9583.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9584.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9584.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9585.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9585.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9586.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9586.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9587.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9587.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9588.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9588.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9589.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9589.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9590.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9590.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9591.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9591.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9592.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9592.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9593.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9593.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9594.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9594.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9595.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9595.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9596.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9596.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9597.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9597.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9598.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9598.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9599.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9599.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9600.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9600.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9601.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9601.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9602.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9602.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9603.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9603.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9604.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9604.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9605.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9605.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9606.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9606.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9607.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9607.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9608.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9608.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9609.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9609.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9610.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9610.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9611.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9611.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9612.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9612.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9613.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9613.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9614.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9614.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9615.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9615.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9616.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9616.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9617.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9617.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9618.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9618.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9619.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9619.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9620.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9620.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9621.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9621.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9622.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9622.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9623.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9623.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9624.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9624.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9625.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9625.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9626.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9626.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9627.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9627.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9628.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9628.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9629.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9629.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9630.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9630.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9631.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9631.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9632.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9632.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9633.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9633.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9634.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9634.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9635.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9635.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9636.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9636.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9637.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9637.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9638.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9638.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9639.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9639.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9640.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9640.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9641.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9641.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9642.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9642.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9643.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9643.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9644.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9644.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9645.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9645.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9646.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9646.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9647.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9647.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9648.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9648.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9649.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9649.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9650.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9650.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9651.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9651.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9652.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9652.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9653.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9653.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9654.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9654.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9655.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9655.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9656.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9656.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9657.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9657.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9658.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9658.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9659.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9659.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9660.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9660.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9661.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9661.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9662.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9662.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9663.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9663.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9664.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9664.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9665.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9665.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9666.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9666.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9667.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9667.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9668.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9668.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9669.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9669.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9670.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9670.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9671.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9671.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9672.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9672.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9673.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9673.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9674.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9674.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9675.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9675.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9676.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9676.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9677.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9677.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9678.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9678.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9679.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9679.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9680.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9680.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9681.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9681.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9682.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9682.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9683.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9683.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9684.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9684.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9685.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9685.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9686.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9686.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9687.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9687.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9688.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9688.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9689.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9689.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9690.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9690.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9691.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9691.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9692.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9692.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9693.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9693.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9694.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9694.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9695.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9695.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9696.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9696.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9697.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9697.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9698.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9698.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9699.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9699.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9700.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9700.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9701.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9701.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9702.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9702.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9703.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9703.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9704.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9704.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9705.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9705.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9706.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9706.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9707.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9707.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9708.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9708.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9709.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9709.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9710.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9710.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9711.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9711.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9712.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9712.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9713.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9713.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9714.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9714.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9715.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9715.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9716.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9716.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9717.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9717.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9718.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9718.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9719.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9719.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9720.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9720.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9721.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9721.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9722.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9722.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9723.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9723.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9724.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9724.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9725.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9725.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9726.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9726.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9727.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9727.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9728.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9728.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9729.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9729.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9730.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9730.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9731.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9731.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9732.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9732.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9733.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9733.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9734.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9734.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9735.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9735.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9736.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9736.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9737.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9737.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9738.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9738.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9739.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9739.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9740.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9740.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9741.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9741.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9742.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9742.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9743.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9743.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9744.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9744.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9745.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9745.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9746.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9746.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9747.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9747.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9748.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9748.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9749.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9749.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9750.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9750.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9751.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9751.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9752.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9752.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9753.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9753.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9754.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9754.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9755.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9755.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9756.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9756.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9757.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9757.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9758.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9758.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9759.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9759.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9760.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9760.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9761.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9761.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9762.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9762.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9763.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9763.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9764.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9764.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9765.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9765.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9766.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9766.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9767.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9767.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9768.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9768.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9769.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9769.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9770.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9770.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9771.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9771.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9772.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9772.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9773.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9773.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9774.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9774.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9775.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9775.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9776.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9776.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9777.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9777.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9778.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9778.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9779.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9779.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9780.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9780.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9781.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9781.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9782.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9782.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9783.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9783.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9784.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9784.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9785.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9785.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9786.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9786.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9787.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9787.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9788.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9788.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9789.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9789.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9790.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9790.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9791.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9791.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9792.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9792.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9793.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9793.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9794.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9794.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9795.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9795.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9796.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9796.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9797.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9797.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9798.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9798.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9799.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9799.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9800.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9800.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9801.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9801.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9802.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9802.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9803.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9803.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9804.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9804.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9805.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9805.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9806.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9806.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9807.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9807.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9808.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9808.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9809.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9809.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9810.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9810.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9811.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9811.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9812.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9812.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9813.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9813.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9814.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9814.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9815.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9815.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9816.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9816.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9817.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9817.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9818.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9818.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9819.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9819.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9820.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9820.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9821.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9821.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9822.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9822.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9823.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9823.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9824.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9824.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9825.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9825.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9826.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9826.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9827.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9827.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9828.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9828.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9829.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9829.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9830.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9830.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9831.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9831.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9832.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9832.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9833.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9833.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9834.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9834.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9835.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9835.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9836.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9836.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9837.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9837.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9838.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9838.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9839.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9839.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9840.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9840.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9841.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9841.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9842.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9842.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9843.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9843.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9844.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9844.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9845.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9845.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9846.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9846.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9847.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9847.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9848.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9848.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9849.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9849.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9850.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9850.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9851.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9851.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9852.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9852.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9853.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9853.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9854.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9854.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9855.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9855.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9856.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9856.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9857.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9857.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9858.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9858.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9859.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9859.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9860.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9860.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9861.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9861.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9862.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9862.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9863.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9863.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9864.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9864.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9865.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9865.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9866.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9866.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9867.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9867.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9868.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9868.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9869.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9869.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9870.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9870.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9871.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9871.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9872.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9872.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9873.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9873.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9874.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9874.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9875.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9875.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9876.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9876.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9877.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9877.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9878.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9878.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9879.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9879.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9880.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9880.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9881.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9881.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9882.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9882.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9883.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9883.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9884.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9884.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9885.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9885.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9886.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9886.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9887.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9887.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9888.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9888.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9889.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9889.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9890.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9890.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9891.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9891.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9892.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9892.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9893.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9893.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9894.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9894.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9895.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9895.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9896.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9896.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9897.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9897.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9898.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9898.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9899.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9899.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9900.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9900.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9901.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9901.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9902.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9902.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9903.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9903.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9904.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9904.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9905.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9905.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9906.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9906.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9907.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9907.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9908.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9908.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9909.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9909.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9910.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9910.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9911.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9911.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9912.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9912.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9913.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9913.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9914.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9914.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9915.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9915.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9916.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9916.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9917.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9917.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9918.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9918.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9919.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9919.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9920.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9920.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9921.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9921.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9922.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9922.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9923.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9923.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9924.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9924.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9925.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9925.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9926.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9926.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9927.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9927.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9928.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9928.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9929.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9929.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9930.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9930.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9931.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9931.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9932.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9932.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9933.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9933.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9934.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9934.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9935.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9935.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9936.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9936.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9937.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9937.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9938.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9938.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9939.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9939.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9940.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9940.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9941.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9941.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9942.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9942.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9943.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9943.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9944.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9944.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9945.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9945.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9946.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9946.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9947.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9947.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9948.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9948.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9949.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9949.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9950.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9950.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9951.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9951.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9952.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9952.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9953.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9953.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9954.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9954.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9955.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9955.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9956.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9956.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9957.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9957.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9958.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9958.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9959.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9959.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9960.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9960.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9961.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9961.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9962.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9962.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9963.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9963.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9964.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9964.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9965.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9965.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9966.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9966.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9967.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9967.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9968.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9968.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9969.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9969.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9970.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9970.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9971.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9971.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9972.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9972.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9973.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9973.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9974.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9974.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9975.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9975.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9976.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9976.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9977.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9977.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9978.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9978.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9979.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9979.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9980.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9980.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9981.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9981.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9982.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9982.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9983.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9983.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9984.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9984.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9985.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9985.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9986.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9986.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9987.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9987.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9988.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9988.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9989.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9989.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9990.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9990.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9991.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9991.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9992.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9992.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9993.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9993.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9994.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9994.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9995.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9995.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9996.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9996.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9997.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9997.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9998.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9998.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-9999.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-9999.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/nfa-0-10000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/large_sequence/cntnfa-0-10000.mata diff --git a/tests-integration/inputs/double-state-explosion.input.in b/tests-integration/inputs/double-state-explosion.input.in new file mode 100644 index 000000000..2f8b35d3a --- /dev/null +++ b/tests-integration/inputs/double-state-explosion.input.in @@ -0,0 +1,6 @@ +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n2.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n3.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n4.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n5.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata +@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/nfa-anbn-n1000.mata;@CMAKE_CURRENT_SOURCE_DIR@/cntnfa-bench/benchmarks/state_explosion/cntnfa-anbn.mata diff --git a/tests-integration/jobs/test-cntnfa-double-param-jobs.yaml.in b/tests-integration/jobs/test-cntnfa-double-param-jobs.yaml.in new file mode 100644 index 000000000..8c6d9189f --- /dev/null +++ b/tests-integration/jobs/test-cntnfa-double-param-jobs.yaml.in @@ -0,0 +1,2 @@ +binary: + cmd: @CMAKE_CURRENT_BINARY_DIR@/cntnfa/test-cntnfa-binary-operations $1 $2 \ No newline at end of file diff --git a/tests-integration/jobs/test-cntnfa-double-state-explosion.yaml.in b/tests-integration/jobs/test-cntnfa-double-state-explosion.yaml.in new file mode 100644 index 000000000..97ec9f15e --- /dev/null +++ b/tests-integration/jobs/test-cntnfa-double-state-explosion.yaml.in @@ -0,0 +1,2 @@ +binary: + cmd: @CMAKE_CURRENT_BINARY_DIR@/cntnfa/test-cntnfa-state-explosion $1 $2 \ No newline at end of file diff --git a/tests-integration/jobs/test-cntnfa-single-param-jobs.yaml.in b/tests-integration/jobs/test-cntnfa-single-param-jobs.yaml.in new file mode 100644 index 000000000..d136e7d63 --- /dev/null +++ b/tests-integration/jobs/test-cntnfa-single-param-jobs.yaml.in @@ -0,0 +1,5 @@ +nfa: + cmd: @CMAKE_CURRENT_BINARY_DIR@/cntnfa/test-cntnfa-operations $1 + +unary: + cmd: @CMAKE_CURRENT_BINARY_DIR@/cntnfa/test-cntnfa-unary-operations $1 \ No newline at end of file diff --git a/tests-integration/src/bench-automata-inclusion.cc b/tests-integration/src/bench-automata-inclusion.cc index 9725eb890..939f0c607 100644 --- a/tests-integration/src/bench-automata-inclusion.cc +++ b/tests-integration/src/bench-automata-inclusion.cc @@ -16,7 +16,7 @@ #include "utils/utils.hh" -constexpr bool MINTERMIZE_AUTOMATA{ true}; +constexpr bool MINTERMIZE_AUTOMATA = true; int main(int argc, char *argv[]) { if (argc != 3) { diff --git a/tests-integration/src/bench-bool-comb-cox-diff.cc b/tests-integration/src/bench-bool-comb-cox-diff.cc index 7821ee34e..f3a11cd8f 100644 --- a/tests-integration/src/bench-bool-comb-cox-diff.cc +++ b/tests-integration/src/bench-bool-comb-cox-diff.cc @@ -10,9 +10,8 @@ */ #include "utils/utils.hh" -#include "mata/nfa/algorithms.hh" -constexpr bool MINTERMIZE_AUTOMATA{ true}; +constexpr bool MINTERMIZE_AUTOMATA = true; int main(int argc, char *argv[]) { if (argc != 3) { diff --git a/tests-integration/src/bench-bool-comb-cox-inter.cc b/tests-integration/src/bench-bool-comb-cox-inter.cc index f970d9667..205c08b7f 100644 --- a/tests-integration/src/bench-bool-comb-cox-inter.cc +++ b/tests-integration/src/bench-bool-comb-cox-inter.cc @@ -11,7 +11,7 @@ #include "utils/utils.hh" -constexpr bool MINTERMIZE_AUTOMATA{ true}; +constexpr bool MINTERMIZE_AUTOMATA = true; int main(int argc, char *argv[]) { if (argc != 3) { diff --git a/tests-integration/src/bench-bool-comb-intersect.cc b/tests-integration/src/bench-bool-comb-intersect.cc index 76a46ea52..36a2f8fc4 100644 --- a/tests-integration/src/bench-bool-comb-intersect.cc +++ b/tests-integration/src/bench-bool-comb-intersect.cc @@ -10,9 +10,8 @@ */ #include "utils/utils.hh" -#include "mata/nfa/algorithms.hh" -constexpr bool MINTERMIZE_AUTOMATA{ true}; +constexpr bool MINTERMIZE_AUTOMATA = true; int main(int argc, char *argv[]) { if (argc <= 2) { diff --git a/tests-integration/src/bench-email-filter.cc b/tests-integration/src/bench-email-filter.cc index ac3579a57..0c0ad0dd1 100644 --- a/tests-integration/src/bench-email-filter.cc +++ b/tests-integration/src/bench-email-filter.cc @@ -15,9 +15,8 @@ */ #include "utils/utils.hh" -#include "mata/nfa/algorithms.hh" -constexpr bool MINTERMIZE_AUTOMATA{ true}; +constexpr bool MINTERMIZE_AUTOMATA = true; int main(int argc, char *argv[]) { if (argc != 6) { diff --git a/tests-integration/src/binary-operations.cc b/tests-integration/src/binary-operations.cc index dd4033198..7b17a4a70 100644 --- a/tests-integration/src/binary-operations.cc +++ b/tests-integration/src/binary-operations.cc @@ -5,7 +5,7 @@ #include "utils/utils.hh" -constexpr bool MINTERMIZE_AUTOMATA{ true}; +constexpr bool MINTERMIZE_AUTOMATA = true; int main(int argc, char *argv[]) { if (argc != 3) { diff --git a/tests-integration/src/cntnfa/test-cntnfa-binary-operations.cc b/tests-integration/src/cntnfa/test-cntnfa-binary-operations.cc new file mode 100644 index 000000000..6297e288d --- /dev/null +++ b/tests-integration/src/cntnfa/test-cntnfa-binary-operations.cc @@ -0,0 +1,61 @@ +/** + * NOTE: Input automata, that are of type `NFA-bits` are mintermized! + * - If you want to skip mintermization, set the variable `MINTERMIZE_AUTOMATA` below to `false` + * - Load NFA and CNTNFA using the same methods for NFA and test them + */ + +#include "../utils/utils.hh" + +constexpr bool MINTERMIZE_AUTOMATA = true; + +int main(int argc, char *argv[]) { + if (argc != 3) { + std::cerr << "Input files missing\n"; + return EXIT_FAILURE; + } + + std::vector filenames {argv[1], argv[2]}; + std::vector cntnfas; + mata::OnTheFlyAlphabet alphabet; + + if (load_counter_automata(filenames, cntnfas, alphabet, MINTERMIZE_AUTOMATA) != EXIT_SUCCESS) { + return EXIT_FAILURE; + } + + // This might be less-efficient, but more readable. + Cntnfa cntnfa_lhs = cntnfas[0]; + Cntnfa cntnfa_rhs = cntnfas[1]; + + // Setting precision of the times to fixed points and 4 decimal places + std::cout << std::fixed << std::setprecision(4); + + // CNTNFA intersection + TIME_BEGIN(intersection); + Cntnfa intersect_cntnfa; + mata::cntnfa::plumbing::intersection(&intersect_cntnfa, cntnfa_lhs, cntnfa_rhs); + TIME_END(intersection); + + // CNTNFA concatenation + TIME_BEGIN(concatenation); + Cntnfa concat_cntnfa; + mata::cntnfa::plumbing::concatenate(&concat_cntnfa, cntnfa_lhs, cntnfa_rhs); + TIME_END(concatenation); + + // CNTNFA union + TIME_BEGIN(union); + Cntnfa union_cntnfa; + mata::cntnfa::plumbing::union_nondet(&union_cntnfa, cntnfa_lhs, cntnfa_rhs); + TIME_END(union); + + // CNTNFA naive inclusion + TIME_BEGIN(naive_inclusion); + mata::cntnfa::algorithms::is_included_naive(cntnfa_lhs, cntnfa_rhs, &alphabet); + TIME_END(naive_inclusion); + + // CNTNFA antichain inclusion + TIME_BEGIN(antichain_inclusion); + mata::cntnfa::algorithms::is_included_antichains(cntnfa_lhs, cntnfa_rhs, &alphabet); + TIME_END(antichain_inclusion); + + return EXIT_SUCCESS; +} diff --git a/tests-integration/src/cntnfa/test-cntnfa-operations.cc b/tests-integration/src/cntnfa/test-cntnfa-operations.cc new file mode 100644 index 000000000..c7dffc33f --- /dev/null +++ b/tests-integration/src/cntnfa/test-cntnfa-operations.cc @@ -0,0 +1,41 @@ +/** + * NOTE: Input automata, that are of type `NFA-bits` are mintermized! + * - If you want to skip mintermization, set the variable `MINTERMIZE_AUTOMATA` below to `false` + * - Load NFA and CNTNFA using the same methods for NFA and test them + */ + +#include "../utils/utils.hh" + +#include "mata/cntnfa/cntnfa.hh" + +#include +#include +#include +#include + +const bool MINTERMIZE_AUTOMATA = true; + +int main(int argc, char *argv[]) { + if (argc != 2) { + std::cerr << "Input file missing\n"; + return EXIT_FAILURE; + } + + std::string filename = argv[1]; + + Cntnfa cntnfa; + mata::OnTheFlyAlphabet alphabet_cntnfa{}; + if (load_counter_automaton(filename, cntnfa, alphabet_cntnfa, MINTERMIZE_AUTOMATA) != EXIT_SUCCESS) { + return EXIT_FAILURE; + } + + // Setting precision of the times to fixed points and 4 decimal places + std::cout << std::fixed << std::setprecision(5); + + TIME_BEGIN(trim); + Cntnfa trimmed_cntnfa = cntnfa; + trimmed_cntnfa.trim(); + TIME_END(trim); + + return EXIT_SUCCESS; +} diff --git a/tests-integration/src/cntnfa/test-cntnfa-state-explosion.cc b/tests-integration/src/cntnfa/test-cntnfa-state-explosion.cc new file mode 100644 index 000000000..abfe0de6d --- /dev/null +++ b/tests-integration/src/cntnfa/test-cntnfa-state-explosion.cc @@ -0,0 +1,84 @@ +// TODO: some header + +#include "../utils/utils.hh" +#include "mata/cntnfa/cntnfa.hh" +#include "mata/nfa/nfa.hh" + +constexpr bool MINTERMIZE_AUTOMATA = false; + +// Helper to create word from the string +mata::Word make_word(const std::string& input, mata::OnTheFlyAlphabet& alphabet) { + mata::Word word; + for (char c : input) { + word.push_back(alphabet.translate_symb(std::string(1, c))); + } + return word; +} + +int main(int argc, char *argv[]) { + if (argc != 3) { + std::cerr << "Input files missing\n"; + return EXIT_FAILURE; + } + + std::string nfa_filename = argv[1]; + std::string cntnfa_filename = argv[2]; + + mata::OnTheFlyAlphabet alphabet; + + // Setting precision of the times to fixed points and 4 decimal places + std::cout << std::fixed << std::setprecision(4); + + // Load NFA + Nfa nfa; + if (load_automaton(nfa_filename, nfa, alphabet, MINTERMIZE_AUTOMATA) != EXIT_SUCCESS) { + return EXIT_FAILURE; + } + + // Load CNTNFA + Cntnfa cntnfa; + TIME_BEGIN(parsing_cntnfa); + if (load_cntnfa_with_counters(cntnfa_filename, cntnfa, alphabet) != EXIT_SUCCESS) { + return EXIT_FAILURE; + } + TIME_END(parsing_cntnfa); + + const int length = 10000; + std::string input(length, '0'); + mata::Word word = make_word(input, alphabet); + + // Membership test + TIME_BEGIN(accepted_by_nfa); + bool nfa_result = nfa.is_in_lang(word); + (void)nfa_result; + TIME_END(accepted_by_nfa); + + TIME_BEGIN(accepted_by_cntnfa); + bool cntnfa_result = cntnfa.is_in_lang_of_counter_nfa(word); + (void)cntnfa_result; + TIME_END(accepted_by_cntnfa); + + // Intersection + TIME_BEGIN(intersection_nfa); + Nfa intersect_nfa; + intersect_nfa = mata::nfa::intersection(nfa, nfa); + TIME_END(intersection_nfa); + + TIME_BEGIN(intersection_cntnfa); + Cntnfa intersect_cntnfa; + intersect_cntnfa = mata::cntnfa::intersection_counter_nfas(cntnfa, cntnfa); + TIME_END(intersection_cntnfa); + + // Union + TIME_BEGIN(union_nfa); + Nfa uni_nfa; + uni_nfa = mata::nfa::union_nondet(nfa, nfa); + TIME_END(union_nfa); + + TIME_BEGIN(union_cntnfa); + Cntnfa uni_cntnfa; + uni_cntnfa = mata::cntnfa::union_nondet_counter_nfas(cntnfa, cntnfa); + TIME_END(union_cntnfa); + + return EXIT_SUCCESS; +} diff --git a/tests-integration/src/cntnfa/test-cntnfa-unary-operations.cc b/tests-integration/src/cntnfa/test-cntnfa-unary-operations.cc new file mode 100644 index 000000000..e18995131 --- /dev/null +++ b/tests-integration/src/cntnfa/test-cntnfa-unary-operations.cc @@ -0,0 +1,95 @@ +#include "../utils/utils.hh" + +#include "mata/alphabet.hh" +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/plumbing.hh" +#include "mata/cntnfa/algorithms.hh" + +#include +#include + +int main(int argc, char *argv[]) { + if (argc != 2) { + std::cerr << "Input file missing\n"; + return EXIT_FAILURE; + } + + std::string filename = argv[1]; + + Cntnfa cntnfa{}; + mata::OnTheFlyAlphabet alphabet{}; + load_counter_automaton(filename, cntnfa, alphabet); + + TIME_BEGIN(complement); + // > START OF PROFILED CODE + // Only complement and its callees will be measured + Cntnfa compl_cntnfa; + mata::cntnfa::plumbing::complement(&compl_cntnfa, cntnfa, alphabet); + // > END OF PROFILED CODE + TIME_END(complement); + + TIME_BEGIN(complement_and_minimize); + // > START OF PROFILED CODE + // Only complement and its callees will be measured + Cntnfa min_compl_cntnfa; + mata::cntnfa::plumbing::complement(&min_compl_cntnfa, cntnfa, alphabet, {{ "algorithm", "classical"}, { "minimize", "true"}}); + // > END OF PROFILED CODE + TIME_END(complement_and_minimize); + + TIME_BEGIN(revert); + // > START OF PROFILED CODE + // Only revert and its callees will be measured + Cntnfa revert_cntnfa; + mata::cntnfa::plumbing::revert(&revert_cntnfa, cntnfa); + // > END OF PROFILED CODE + TIME_END(revert); + + TIME_BEGIN(reduce_and_trim); + // > START OF PROFILED CODE + // Only reduce and its callees will be measured + Cntnfa trimmed_cntnfa{cntnfa}; + Cntnfa reduced_cntnfa; + mata::cntnfa::plumbing::reduce(&reduced_cntnfa, trimmed_cntnfa.trim()); + // > END OF PROFILED CODE + TIME_END(reduce_and_trim); + + TIME_BEGIN(reduce); + // > START OF PROFILED CODE + // Only reduce and its callees will be measured + Cntnfa untrimmed_reduced_cntnfa; + mata::cntnfa::plumbing::reduce(&untrimmed_reduced_cntnfa, cntnfa); + // > END OF PROFILED CODE + TIME_END(reduce); + + TIME_BEGIN(minimize); + // > START OF PROFILED CODE + // Only minimize and its callees will be measured + Cntnfa minimized_cntnfa; + mata::cntnfa::plumbing::minimize(&minimized_cntnfa, cntnfa); + // > END OF PROFILED CODE + TIME_END(minimize); + + TIME_BEGIN(determinize); + // > START OF PROFILED CODE + // Only determinize and its callees will be measured + Cntnfa det_cntnfa; + mata::cntnfa::plumbing::determinize(&det_cntnfa, cntnfa); + // > END OF PROFILED CODE + TIME_END(determinize); + + TIME_BEGIN(naive_universality); + // > START OF PROFILED CODE + // Only universality check and its callees will be measured + mata::cntnfa::algorithms::is_universal_naive(cntnfa, alphabet, nullptr); + // > END OF PROFILED CODE + TIME_END(naive_universality); + + TIME_BEGIN(antichain_universality); + // > START OF PROFILED CODE + // Only universality check and its callees will be measured + mata::cntnfa::algorithms::is_universal_antichains(cntnfa, alphabet, nullptr); + // > END OF PROFILED CODE + TIME_END(antichain_universality); + + return EXIT_SUCCESS; +} diff --git a/tests-integration/src/nfa-operations.cc b/tests-integration/src/nfa-operations.cc index e8adcc590..09f6b49f1 100644 --- a/tests-integration/src/nfa-operations.cc +++ b/tests-integration/src/nfa-operations.cc @@ -9,12 +9,9 @@ #include #include -#include #include -using namespace mata::nfa; - -const bool MINTERMIZE_AUTOMATA{ true}; +const bool MINTERMIZE_AUTOMATA = true; int main(int argc, char *argv[]) { if (argc != 2) { diff --git a/tests-integration/src/reduce_epsilon.cc b/tests-integration/src/reduce_epsilon.cc index 5d82eb0f5..db389d7dd 100644 --- a/tests-integration/src/reduce_epsilon.cc +++ b/tests-integration/src/reduce_epsilon.cc @@ -3,15 +3,8 @@ #include "mata/nfa/nfa.hh" #include -#include -#include -#include -#include -#include #include -using namespace mata::nfa; - int main() { Nfa b{10}; b.initial.insert(0); @@ -19,11 +12,11 @@ int main() { b.delta.add(0, 'b', 1); b.delta.add(0, 'a', 2); b.delta.add(2, 'a', 4); - b.delta.add(2, EPSILON, 3); + b.delta.add(2, mata::nfa::EPSILON, 3); b.delta.add(3, 'b', 4); b.delta.add(0, 'c', 5); b.delta.add(5, 'a', 8); - b.delta.add(5, EPSILON, 6); + b.delta.add(5, mata::nfa::EPSILON, 6); b.delta.add(6, 'a', 9); b.delta.add(6, 'b', 7); diff --git a/tests-integration/src/test-unary-op.cc b/tests-integration/src/test-unary-op.cc index 770610d86..3aa530bbd 100644 --- a/tests-integration/src/test-unary-op.cc +++ b/tests-integration/src/test-unary-op.cc @@ -11,8 +11,6 @@ #include #include -using namespace mata::nfa; - const bool MINTERMIZE_AUTOMATA = true; int main(int argc, char *argv[]) { diff --git a/tests-integration/src/unary-operations.cc b/tests-integration/src/unary-operations.cc index 9b2cb175f..06b3cae9c 100644 --- a/tests-integration/src/unary-operations.cc +++ b/tests-integration/src/unary-operations.cc @@ -5,11 +5,8 @@ #include "mata/nfa/algorithms.hh" #include -#include #include -using namespace mata::nfa; - int main(int argc, char *argv[]) { if (argc != 2) { std::cerr << "Input file missing\n"; diff --git a/tests-integration/src/utils/utils.cc b/tests-integration/src/utils/utils.cc index e85f8fd47..deed816d0 100644 --- a/tests-integration/src/utils/utils.cc +++ b/tests-integration/src/utils/utils.cc @@ -3,6 +3,8 @@ #include "mata/nfa/types.hh" #include "mata/parser/inter-aut.hh" +namespace mata::nfa { + int load_automaton( const std::string& filename, Nfa& aut, @@ -10,20 +12,20 @@ int load_automaton( const bool mintermize_automata ) { std::vector inter_auts; - TIME_BEGIN(parsing); + TIME_BEGIN(parsing_nfa); if (load_intermediate_automaton(filename, inter_auts) != EXIT_SUCCESS) { std::cerr << "Could not load intermediate autotomaton from \'" << filename << "'\n"; return EXIT_FAILURE; } - TIME_END(parsing); + TIME_END(parsing_nfa); try { if (!mintermize_automata or inter_auts[0].alphabet_type != mata::IntermediateAut::AlphabetType::BITVECTOR) { aut = mata::nfa::builder::construct(inter_auts[0], &alphabet); } else { mata::Mintermization mintermization; - TIME_BEGIN(mintermization); + TIME_BEGIN(mintermization_nfa); mata::IntermediateAut mintermized = mintermization.mintermize(inter_auts[0]); - TIME_END(mintermization); + TIME_END(mintermization_nfa); aut = mata::nfa::builder::construct(mintermized, &alphabet); } return EXIT_SUCCESS; @@ -41,14 +43,14 @@ int load_automata( const bool mintermize_automata ) { std::vector inter_auts; - TIME_BEGIN(parsing); + TIME_BEGIN(parsing_nfa); for (const std::string& filename : filenames) { if (load_intermediate_automaton(filename, inter_auts) != EXIT_SUCCESS) { std::cerr << "Could not load intermediate autotomaton from \'" << filename << "'\n"; return EXIT_FAILURE; } } - TIME_END(parsing); + TIME_END(parsing_nfa); try { if (!mintermize_automata or inter_auts[0].alphabet_type != mata::IntermediateAut::AlphabetType::BITVECTOR) { // This is not foolproof and assumes, that everything is BITVECTOR @@ -58,9 +60,9 @@ int load_automata( } } else { mata::Mintermization mintermization; - TIME_BEGIN(mintermization); + TIME_BEGIN(mintermization_nfa); std::vector mintermized = mintermization.mintermize(inter_auts); - TIME_END(mintermization); + TIME_END(mintermization_nfa); for (mata::IntermediateAut& inter_aut : mintermized) { assert(inter_aut.alphabet_type == mata::IntermediateAut::AlphabetType::BITVECTOR); auts.push_back(mata::nfa::builder::construct(inter_aut, &alphabet)); @@ -93,6 +95,7 @@ int load_intermediate_automaton( throw std::runtime_error( "The number of sections in the input file is not 1\n"); } + if (!parsed[0].type.starts_with(TYPE_NFA)) { std::cout << (parsed[0].type) << std::endl; throw std::runtime_error("The type of input automaton is not NFA\n"); @@ -108,3 +111,142 @@ int load_intermediate_automaton( return EXIT_SUCCESS; } + +} // namespace mata::nfa + +namespace mata::cntnfa { + +int load_counter_automaton( + const std::string& filename, + Cntnfa& aut, + mata::OnTheFlyAlphabet& alphabet, + const bool mintermize_automata +) { + std::vector inter_auts; + TIME_BEGIN(parsing_cntnfa); + if (load_intermediate_counter_automaton(filename, inter_auts) != EXIT_SUCCESS) { + std::cerr << "Could not load intermediate autotomaton from \'" << filename << "'\n"; + return EXIT_FAILURE; + } + TIME_END(parsing_cntnfa); + try { + if (!mintermize_automata or inter_auts[0].alphabet_type != mata::IntermediateAut::AlphabetType::BITVECTOR) { + aut = mata::cntnfa::builder::construct(inter_auts[0], &alphabet); + } else { + mata::Mintermization mintermization; + TIME_BEGIN(mintermization_cntnfa); + mata::IntermediateAut mintermized = mintermization.mintermize(inter_auts[0]); + TIME_END(mintermization_cntnfa); + aut = mata::cntnfa::builder::construct(mintermized, &alphabet); + } + return EXIT_SUCCESS; + } + catch (const std::exception& ex) { + std::cerr << "error: " << ex.what() << "\n"; + return EXIT_FAILURE; + } +} + +int load_counter_automata( + std::vector& filenames, + std::vector& auts, + mata::OnTheFlyAlphabet& alphabet, + const bool mintermize_automata +) { + std::vector inter_auts; + TIME_BEGIN(parsing_cntnfa); + for (const std::string& filename : filenames) { + if (load_intermediate_counter_automaton(filename, inter_auts) != EXIT_SUCCESS) { + std::cerr << "Could not load intermediate autotomaton from \'" << filename << "'\n"; + return EXIT_FAILURE; + } + } + TIME_END(parsing_cntnfa); + try { + if (!mintermize_automata or inter_auts[0].alphabet_type != mata::IntermediateAut::AlphabetType::BITVECTOR) { + // This is not foolproof and assumes, that everything is BITVECTOR + for (mata::IntermediateAut& inter_aut : inter_auts) { + assert(inter_aut.alphabet_type == mata::IntermediateAut::AlphabetType::BITVECTOR); + auts.push_back(mata::cntnfa::builder::construct(inter_aut, &alphabet)); + } + } else { + mata::Mintermization mintermization; + TIME_BEGIN(mintermization_cntnfa); + std::vector mintermized = mintermization.mintermize(inter_auts); + TIME_END(mintermization_cntnfa); + for (mata::IntermediateAut& inter_aut : mintermized) { + assert(inter_aut.alphabet_type == mata::IntermediateAut::AlphabetType::BITVECTOR); + auts.push_back(mata::cntnfa::builder::construct(inter_aut, &alphabet)); + } + } + return EXIT_SUCCESS; + } + catch (const std::exception& ex) { + std::cerr << "error: " << ex.what() << "\n"; + return EXIT_FAILURE; + } +} + +int load_intermediate_counter_automaton( + const std::string& filename, + std::vector& out_inter_auts +) { + std::fstream fs(filename, std::ios::in); + if (!fs) { + std::cerr << "Could not open file \'" << filename << "'\n"; + return EXIT_FAILURE; + } + + mata::parser::Parsed parsed; + try { + parsed = mata::parser::parse_mf(fs, true); + fs.close(); + + if (parsed.size() != 1) { + throw std::runtime_error( + "The number of sections in the input file is not 1\n"); + } + + // Note: We need to use the NFA type here, becuase the parser does not support the CNTNFA type. + if (!(parsed[0].type.starts_with(mata::nfa::TYPE_NFA) || parsed[0].type.starts_with(TYPE_CNTNFA))) { + std::cout << (parsed[0].type) << std::endl; + throw std::runtime_error("The type of input automaton is not NFA\n"); + } + + std::vector inter_auts = mata::IntermediateAut::parse_from_mf(parsed); + out_inter_auts.push_back(inter_auts[0]); + } catch (const std::exception& ex) { + fs.close(); + std::cerr << "error: " << ex.what() << "\n"; + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} + +int load_cntnfa_with_counters( + const std::string& filename, + Cntnfa& aut, + mata::OnTheFlyAlphabet& alphabet +) { + // Open the file + std::ifstream file(filename); + if (!file.is_open()) { + std::cerr << "Could not open CNTNFA file: " << filename << "\n"; + return EXIT_FAILURE; + } + + try { + // Parse the CNTNFA section + mata::parser::ParsedSection section = mata::parser::parse_mf_section(file); + file.close(); + // Construct the CNTNFA + aut = builder::construct_counter_nfa(section, &alphabet); + return EXIT_SUCCESS; + } catch (const std::exception& ex) { + std::cerr << "Failed to load CNTNFA: " << ex.what() << "\n"; + return EXIT_FAILURE; + } +} + +} // namespace mata::cntnfa diff --git a/tests-integration/src/utils/utils.hh b/tests-integration/src/utils/utils.hh index 96682256c..a71126546 100644 --- a/tests-integration/src/utils/utils.hh +++ b/tests-integration/src/utils/utils.hh @@ -3,20 +3,25 @@ #ifndef MATA_TESTS_PERFORMANCE_UTILS_HH #define MATA_TESTS_PERFORMANCE_UTILS_HH -#include "mata/parser/inter-aut.hh" #include "mata/nfa/nfa.hh" #include "mata/nfa/plumbing.hh" #include "mata/nfa/algorithms.hh" + +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/plumbing.hh" +#include "mata/cntnfa/algorithms.hh" + +#include "mata/parser/inter-aut.hh" #include "mata/parser/mintermization.hh" +#include #include #include #include #include -#include #include -using namespace mata::nfa; +namespace mata::nfa { /** * @brief Load automaton from file at @p filename into @p aut, using @p alphabet for symbols on transitions. @@ -65,6 +70,51 @@ int load_intermediate_automaton( std::vector& out_inter_auts ); +} // namespace mata::nfa + +namespace mata::cntnfa { + +/** + * @brief Load counter automaton from file at @p filename into @p aut, using @p alphabet for symbols on transitions. + */ +int load_counter_automaton( + const std::string& filename, + Cntnfa& aut, + mata::OnTheFlyAlphabet& alphabet, + const bool mintermize_automata = true +); + +/** + * @brief Load counter automata from list of files at @p filename into list of counter automata @p aut, + * using @p alphabet for symbols on transitions. + */ +int load_counter_automata( + std::vector& filenames, + std::vector& auts, + mata::OnTheFlyAlphabet& alphabet, + const bool mintermize_automata = true +); + +/** + * @brief Load counter automaton from file at @p filename into @p inter_aut + */ +int load_intermediate_counter_automaton( + const std::string& filename, + std::vector& out_inter_auts +); + +/** + * @brief Load counter automaton with counters from file at @p filename into @p aut, + * using @p alphabet for symbols on transitions. + */ +int load_cntnfa_with_counters( + const std::string& filename, + Cntnfa& aut, + mata::OnTheFlyAlphabet& alphabet +); + +} // namepace mata::cntnfa + /* * Use to print elapsed time of set of timers with user-defined prefix `timer` */ diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index eb695cff6..f2cc70ba2 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -22,6 +22,10 @@ add_executable(tests nft/nft-profiling.cc nft/nft-plumbing.cc nft/strings.cc + cntnfa/delta.cc + cntnfa/cntnfa.cc + cntnfa/annotations.cc + cntnfa/builder.cc strings/nfa-noodlification.cc strings/nfa-segmentation.cc strings/nfa-string-solving.cc diff --git a/tests/cntnfa/annotations.cc b/tests/cntnfa/annotations.cc new file mode 100644 index 000000000..1f0dfce5a --- /dev/null +++ b/tests/cntnfa/annotations.cc @@ -0,0 +1,16 @@ +// TODO: some header + +#include "mata/cntnfa/annotations.hh" +#include +#include + +#include "mata/cntnfa/cntnfa.hh" + +using namespace mata; +using namespace mata::cntnfa; + +TEST_CASE("Cntnfa: Allocate annotation collection for counter NFA") { + Cntnfa cntnfa{}; + cntnfa.annotation_collection.allocate(3); + CHECK(cntnfa.num_of_annotation_sets() == 3); +} diff --git a/tests/cntnfa/builder.cc b/tests/cntnfa/builder.cc new file mode 100644 index 000000000..ee794ff65 --- /dev/null +++ b/tests/cntnfa/builder.cc @@ -0,0 +1,518 @@ +// TODO: some header + +#include + +#include +#include + +#include "mata/cntnfa/annotations.hh" +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/types.hh" +#include "mata/cntnfa/builder.hh" + +using namespace mata::cntnfa; +using Symbol = mata::Symbol; +using IntAlphabet = mata::IntAlphabet; +using OnTheFlyAlphabet = mata::OnTheFlyAlphabet; + +using Word = std::vector; + +TEST_CASE("Cntnfa: construct_counter_nfa()") { + SECTION("Empty automaton - No initial and final states, no registers") { + Cntnfa nfa; + + std::string input = R"(@CNTNFA-explicit + %Alphabet-auto + )"; + + SECTION("From string") { + auto section = mata::parser::parse_mf_section(input); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + } + + SECTION("From file") { + std::filesystem::path file_path = "temp-empty-noinitfinalregs.mata"; + std::ofstream(file_path) << input; + std::ifstream file(file_path); + auto section = mata::parser::parse_mf_section(file); + file.close(); + std::filesystem::remove(file_path); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + } + } + + SECTION("Empty automaton - Empty initial and final states, empty registers") { + Cntnfa nfa; + + std::string input = R"(@CNTNFA-explicit + %Alphabet-auto + %Initial + %Final + %Registers + )"; + + SECTION("From string") { + auto section = mata::parser::parse_mf_section(input); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + } + + SECTION("From file") { + std::filesystem::path file_path = "temp-empty-initfinalregs.mata"; + std::ofstream(file_path) << input; + std::ifstream file(file_path); + auto section = mata::parser::parse_mf_section(file); + file.close(); + std::filesystem::remove(file_path); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + } + } + + SECTION("Simple automaton - Empty registers") { + Cntnfa nfa; + nfa.initial = { 0 }; + nfa.delta.add(0, 0, 0); + nfa.delta.add(0, 1, 1); + nfa.delta.add(1, 2, 0); + nfa.final = { 1 }; + + std::string input = R"(@CNTNFA-explicit + %Alphabet-auto + %Initial q0 + %Final q1 + %Registers + q0 0 q0 + q0 1 q1 + q1 2 q0 + )"; + + SECTION("From string") { + auto section = mata::parser::parse_mf_section(input); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + } + + SECTION("From file") { + std::filesystem::path file_path = "temp-simple-emptyregs.mata"; + std::ofstream(file_path) << input; + std::ifstream file(file_path); + auto section = mata::parser::parse_mf_section(file); + file.close(); + std::filesystem::remove(file_path); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + } + } + + SECTION("Larget automaton - Empty registers") { + Cntnfa nfa; + nfa.initial = { 1, 2, 50 }; + nfa.delta.add(1, 'a', 2); + nfa.delta.add(1, 'a', 3); + nfa.delta.add(1, 'b', 4); + nfa.delta.add(2, 'a', 2); + nfa.delta.add(2, 'b', 2); + nfa.delta.add(2, 'a', 3); + nfa.delta.add(2, 'b', 4); + nfa.delta.add(3, 'b', 4); + nfa.delta.add(3, 'c', 7); + nfa.delta.add(3, 'b', 2); + nfa.delta.add(5, 'c', 3); + nfa.delta.add(7, 'a', 8); + nfa.delta.add(12, 'b', 15); + nfa.delta.add(1, 'b', 40); + nfa.delta.add(51, 'z', 42); + nfa.final = { 3, 103 }; + + std::string input = R"(@CNTNFA-explicit + %Alphabet-auto + %Initial q1 q2 q50 + %Final q3 q103 + %Registers + q1 a q2 + q1 a q3 + q1 b q4 + q2 a q2 + q2 b q2 + q2 a q3 + q2 b q4 + q3 b q4 + q3 c q7 + q3 b q2 + q5 c q3 + q7 a q8 + q12 b q15 + q1 b q40 + q51 z q42 + )"; + + SECTION("From string") { + mata::parser::ParsedSection section = mata::parser::parse_mf_section(input); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + } + + SECTION("From file") { + std::filesystem::path file_path = "temp-larger-emptyregs.mata"; + std::ofstream(file_path) << input; + std::ifstream file(file_path); + auto section = mata::parser::parse_mf_section(file); + file.close(); + std::filesystem::remove(file_path); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + } + } + + SECTION("Simple automaton - With annotations (only equal and increment)") { + Cntnfa nfa; + nfa.initial = { 0 }; + nfa.final = { 1 }; + + // Counters + size_t c0 = nfa.counter_set.add("c0"); + size_t c1 = nfa.counter_set.add("c1"); + + // Annotations + size_t ann0 = nfa.create_annotation_set(); + size_t ann1 = nfa.create_annotation_set(); + nfa.add_annotation(ann0, std::make_shared(c0, 0)); + nfa.add_annotation(ann1, std::make_shared(c1, 1)); + + // Transitions + nfa.delta.add(0, 0, Target{0, UNDEFINED_ANNOTATIONS}); + nfa.delta.add(0, 1, Target{1, ann0}); + nfa.delta.add(1, 2, Target{0, ann1}); + + std::string input = R"(@CNTNFA-explicit + %Alphabet-auto + %Initial q0 + %Final q1 + %Registers c0 c1 + q0 0 q0 + q0 1 (= c0 0) q1 + q1 2 (+ c1 1) q0 + )"; + + SECTION("From string") { + auto section = mata::parser::parse_mf_section(input); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + + CHECK(parsed.get_annotation_set(0).size() == nfa.get_annotation_set(0).size()); + CHECK(parsed.get_annotation_set(1).size() == nfa.get_annotation_set(1).size()); + } + + SECTION("From file") { + std::filesystem::path file_path = "temp-simple-withanns.mata"; + std::ofstream(file_path) << input; + std::ifstream file(file_path); + auto section = mata::parser::parse_mf_section(file); + file.close(); + std::filesystem::remove(file_path); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + + CHECK(parsed.get_annotation_set(0).size() == nfa.get_annotation_set(0).size()); + CHECK(parsed.get_annotation_set(1).size() == nfa.get_annotation_set(1).size()); + } + } + + SECTION("Larger automaton - With annotations (only equal and increment)") { + Cntnfa nfa; + nfa.initial = { 0, 5 }; + nfa.final = { 8, 10 }; + + // Counters + size_t c0 = nfa.counter_set.add("c0"); + size_t c1 = nfa.counter_set.add("c1"); + size_t c2 = nfa.counter_set.add("c2"); + + // Annotations + size_t ann0 = nfa.create_annotation_set(); + size_t ann1 = nfa.create_annotation_set(); + size_t ann2 = nfa.create_annotation_set(); + size_t ann3 = nfa.create_annotation_set(); + size_t ann4 = nfa.create_annotation_set(); + size_t ann5 = nfa.create_annotation_set(); + size_t ann6 = nfa.create_annotation_set(); + size_t ann7 = nfa.create_annotation_set(); + + nfa.add_annotation(ann0, std::make_shared(c0, 0)); // = c0 0 + nfa.add_annotation(ann1, std::make_shared(c1, 1));// + c1 1 + nfa.add_annotation(ann2, std::make_shared(c1, 1)); // = c1 1 + nfa.add_annotation(ann2, std::make_shared(c2, 2));// + c2 2 + nfa.add_annotation(ann3, std::make_shared(c1, 1));// + c1 1 + nfa.add_annotation(ann4, std::make_shared(c0, 3));// + c0 3 + nfa.add_annotation(ann5, std::make_shared(c1, 1)); // = c1 1 + nfa.add_annotation(ann5, std::make_shared(c2, 2));// + c2 2 + nfa.add_annotation(ann6, std::make_shared(c0, 0)); // = c0 0 + nfa.add_annotation(ann7, std::make_shared(c1, 1)); // = c1 1 + nfa.add_annotation(ann7, std::make_shared(c2, 2));// + c2 2 + + // Transitions + nfa.delta.add(0, 'a', Target{1, ann0}); + nfa.delta.add(1, 'b', Target{2, ann1}); + nfa.delta.add(2, 'c', Target{3, ann2}); + nfa.delta.add(3, 'd', Target{4, UNDEFINED_ANNOTATIONS}); + nfa.delta.add(4, 'e', Target{5, ann3}); + nfa.delta.add(5, 'f', Target{6, ann4}); + nfa.delta.add(6, 'g', Target{7, ann5}); + nfa.delta.add(7, 'h', Target{8, UNDEFINED_ANNOTATIONS}); + nfa.delta.add(8, 'i', Target{9, ann6}); + nfa.delta.add(9, 'j', Target{10, ann7}); + + std::string input = R"(@CNTNFA-explicit + %Alphabet-auto + %Initial q0 q5 + %Final q8 q10 + %Registers c0 c1 c2 + q0 a (= c0 0) q1 + q1 b (+ c1 1) q2 + q2 c (= c1 1) (+ c2 2) q3 + q3 d q4 + q4 e (+ c1 1) q5 + q5 f (+ c0 3) q6 + q6 g (= c1 1) (+ c2 2) q7 + q7 h q8 + q8 i (= c0 0) q9 + q9 j (= c1 1) (+ c2 2) q10 + )"; + + SECTION("From string") { + auto section = mata::parser::parse_mf_section(input); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + + CHECK(parsed.get_annotation_set(0).size() == nfa.get_annotation_set(0).size()); + CHECK(parsed.get_annotation_set(1).size() == nfa.get_annotation_set(1).size()); + } + + SECTION("From file") { + std::filesystem::path file_path = "temp-simple-withanns.mata"; + std::ofstream(file_path) << input; + std::ifstream file(file_path); + auto section = mata::parser::parse_mf_section(file); + file.close(); + std::filesystem::remove(file_path); + + OnTheFlyAlphabet alphabet; + Cntnfa parsed = builder::construct_counter_nfa(section, &alphabet); + + CHECK(parsed.initial == nfa.initial); + CHECK(parsed.final == nfa.final); + CHECK(parsed.counter_set.size() == nfa.counter_set.size()); + CHECK(parsed.annotation_collection.size() == nfa.annotation_collection.size()); + CHECK(parsed.delta.num_of_transitions() == nfa.delta.num_of_transitions()); + + CHECK(parsed.get_annotation_set(0).size() == nfa.get_annotation_set(0).size()); + CHECK(parsed.get_annotation_set(1).size() == nfa.get_annotation_set(1).size()); + } + } +} + +TEST_CASE("Cntnfa: parse_from_mata()") { + Delta delta; + + SECTION("Empty automaton - No initial and final") { + Cntnfa nfa{ delta, {}, {} }; + SECTION("from String") { + std::string empty_nfa_str = "@NFA-explicit\n%Alphabet-auto\n"; + Cntnfa empty_nfa{ mata::cntnfa::builder::parse_from_mata(empty_nfa_str) }; + CHECK(are_equivalent(empty_nfa, nfa)); + } + + SECTION("from file") { + std::filesystem::path nfa_file{ "./temp-test-parse_from_mata-empty_nfa.mata" }; + std::fstream file{ nfa_file, std::fstream::in | std::fstream::out | std::fstream::trunc }; + file << "@NFA-explicit\n%Alphabet-auto\n"; + file.close(); + Cntnfa parsed{ mata::cntnfa::builder::parse_from_mata(nfa_file) }; + std::filesystem::remove(nfa_file); + CHECK(are_equivalent(parsed, nfa)); + } + + } + + SECTION("Empty automaton with empty final and initial") { + Cntnfa nfa{ delta, {}, {} }; + SECTION("from String") { + std::string empty_nfa_str = "@NFA-explicit\n%Alphabet-auto\n%Initial\n%Final\n"; + Cntnfa empty_nfa{ mata::cntnfa::builder::parse_from_mata(empty_nfa_str) }; + CHECK(are_equivalent(empty_nfa, nfa)); + } + SECTION("from file") { + std::filesystem::path nfa_file{ "./temp-test-parse_from_mata-empty_nfa-empty_initial_final.mata" }; + std::fstream file{ nfa_file, std::fstream::in | std::fstream::out | std::fstream::trunc }; + file << "@NFA-explicit\n%Alphabet-auto\n%Initial\n%Final\n"; + file.close(); + Cntnfa parsed{ mata::cntnfa::builder::parse_from_mata(nfa_file) }; + std::filesystem::remove(nfa_file); + CHECK(are_equivalent(parsed, nfa)); + } + } + + SECTION("Simple automaton") { + delta.add(0, 0, 0); + delta.add(0, 1, 1); + delta.add(1, 2, 0); + Cntnfa nfa{ delta, { 0 }, { 1 } }; + + SECTION("from string") { + Cntnfa parsed{ mata::cntnfa::builder::parse_from_mata(nfa.print_to_mata()) }; + CHECK(are_equivalent(parsed, nfa)); + } + + SECTION("from stream") { + std::stringstream nfa_stream; + nfa.print_to_mata(nfa_stream); + Cntnfa parsed{ mata::cntnfa::builder::parse_from_mata(nfa_stream) }; + CHECK(are_equivalent(parsed, nfa)); + } + + SECTION("from file") { + std::filesystem::path nfa_file{ "./temp-test-parse_from_mata-simple_nfa.mata" }; + std::fstream file{ nfa_file, std::fstream::in | std::fstream::out | std::fstream::trunc}; + nfa.print_to_mata(file); + Cntnfa parsed{ mata::cntnfa::builder::parse_from_mata(nfa_file) }; + file.close(); + std::filesystem::remove(nfa_file); + + CHECK(are_equivalent(parsed, nfa)); + } + + } + + SECTION("larger automaton") { + Cntnfa nfa; + nfa.initial = { 1, 2, 50 }; + nfa.delta.add(1, 'a', 2); + nfa.delta.add(1, 'a', 3); + nfa.delta.add(1, 'b', 4); + nfa.delta.add(2, 'a', 2); + nfa.delta.add(2, 'b', 2); + nfa.delta.add(2, 'a', 3); + nfa.delta.add(2, 'b', 4); + nfa.delta.add(3, 'b', 4); + nfa.delta.add(3, 'c', 7); + nfa.delta.add(3, 'b', 2); + nfa.delta.add(5, 'c', 3); + nfa.delta.add(7, 'a', 8); + nfa.delta.add(12, 'b', 15); + nfa.delta.add(1, 'b', 40); + nfa.delta.add(51, 'z', 42); + nfa.final = { 3, 103 }; + + SECTION("from string") { + Cntnfa parsed{ mata::cntnfa::builder::parse_from_mata(nfa.print_to_mata()) }; + parsed.final.contains(103); + parsed.initial.contains(50); + parsed.delta.contains(51, 'z', 42); + CHECK(are_equivalent(parsed, nfa)); + } + + SECTION("from stream") { + std::stringstream nfa_stream; + nfa.print_to_mata(nfa_stream); + Cntnfa parsed{ mata::cntnfa::builder::parse_from_mata(nfa_stream) }; + parsed.final.contains(103); + parsed.initial.contains(50); + parsed.delta.contains(51, 'z', 42); + CHECK(are_equivalent(parsed, nfa)); + } + + SECTION("from file") { + std::filesystem::path nfa_file{ "./temp-test-parse_from_mata-larger_nfa.mata" }; + std::fstream file{ nfa_file, std::fstream::in | std::fstream::out | std::fstream::trunc }; + nfa.print_to_mata(file); + Cntnfa parsed{ mata::cntnfa::builder::parse_from_mata(nfa_file) }; + file.close(); + std::filesystem::remove(nfa_file); + + parsed.final.contains(103); + parsed.initial.contains(50); + parsed.delta.contains(51, 'z', 42); + CHECK(are_equivalent(parsed, nfa)); + } + } +} diff --git a/tests/cntnfa/cntnfa.cc b/tests/cntnfa/cntnfa.cc new file mode 100644 index 000000000..f9461bc75 --- /dev/null +++ b/tests/cntnfa/cntnfa.cc @@ -0,0 +1,4988 @@ +// TODO: some header + +#include +#include + +#include "utils.hh" + +#include "mata/utils/sparse-set.hh" +#include "mata/cntnfa/delta.hh" +#include "mata/cntnfa/cntnfa.hh" +#include "mata/cntnfa/strings.hh" +#include "mata/cntnfa/builder.hh" +#include "mata/cntnfa/plumbing.hh" +#include "mata/cntnfa/algorithms.hh" + +using namespace mata; +using namespace mata::cntnfa::algorithms; +using namespace mata::cntnfa; +using namespace mata::strings; +using namespace mata::cntnfa::plumbing; +using namespace mata::utils; +using namespace mata::parser; +using Symbol = mata::Symbol; +using Word = mata::Word; +using IntAlphabet = mata::IntAlphabet; +using OnTheFlyAlphabet = mata::OnTheFlyAlphabet; + +TEST_CASE("mata::cntnfa::size()") { + Cntnfa nfa{}; + CHECK(nfa.num_of_states() == 0); + + nfa.add_state(3); + CHECK(nfa.num_of_states() == 4); + + nfa.clear(); + nfa.add_state(); + CHECK(nfa.num_of_states() == 1); + + nfa.clear(); + FILL_WITH_AUT_A(nfa); + CHECK(nfa.num_of_states() == 11); + + nfa.clear(); + FILL_WITH_AUT_B(nfa); + CHECK(nfa.num_of_states() == 15); + + nfa = Cntnfa{ 0, {}, {} }; + CHECK(nfa.num_of_states() == 0); +} + +TEST_CASE("Cntnfa: StatePost::emplace_back()") { + StatePost state_post{}; + state_post.emplace_back(1, StateSet{2, 3}); + CHECK(state_post == StatePost{ SymbolPost{ Symbol{ 1 }, StateSet{ 2, 3 } } }); + CHECK(*state_post.find(1) == SymbolPost{ SymbolPost{ Symbol{ 1 }, StateSet{ 2, 3 } } }); +} + +TEST_CASE("mata::cntnfa::Trans::operator<<") { + Transition trans(1, 2, 3); + REQUIRE(std::to_string(trans) == "(1, 2, 3)"); +} + +TEST_CASE("mata::cntnfa::create_alphabet()") { + Cntnfa a{1}; + a.delta.add(0, 'a', 0); + + Cntnfa b{1}; + b.delta.add(0, 'b', 0); + b.delta.add(0, 'a', 0); + Cntnfa c{1}; + b.delta.add(0, 'c', 0); + + auto alphabet{ create_alphabet(a, b, c) }; + + auto symbols{alphabet.get_alphabet_symbols() }; + CHECK(symbols == mata::utils::OrdVector{ 'c', 'b', 'a' }); + + // create_alphabet(1, 3, 4); // Will not compile: '1', '3', '4' are not of the required type. + // create_alphabet(a, b, 4); // Will not compile: '4' is not of the required type. +} + +TEST_CASE("mata::cntnfa::Cntnfa::delta.add()/delta.contains()") +{ // {{{ + Cntnfa a(3); + + SECTION("Empty automata have now transitions") + { + REQUIRE(!a.delta.contains(1, 'a', 1)); + } + + SECTION("If I add a transition, it is in the automaton") + { + a.delta.add(1, 'a', 1); + + REQUIRE(a.delta.contains(1, 'a', 1)); + } + + SECTION("If I add a transition, only it is added") + { + a.delta.add(1, 'a', 1); + + REQUIRE(a.delta.contains(1, 'a', 1)); + REQUIRE(!a.delta.contains(1, 'a', 2)); + REQUIRE(!a.delta.contains(1, 'b', 2)); + REQUIRE(!a.delta.contains(2, 'a', 1)); + } + + SECTION("Adding multiple transitions") + { + a.delta.add(2, 'b', {2,1,0}); + REQUIRE(a.delta.contains(2, 'b', 0)); + REQUIRE(a.delta.contains(2, 'b', 1)); + REQUIRE(a.delta.contains(2, 'b', 2)); + REQUIRE(!a.delta.contains(0, 'b', 0)); + + a.delta.add(0, 'b', StateSet({0})); + REQUIRE(a.delta.contains(0, 'b', 0)); + } + + SECTION("Iterating over transitions") { + Transition t1{ 0, 0, 0}; + Transition t2{ 0, 1, 0}; + Transition t3{ 1, 1, 1}; + Transition t4{ 2, 2, 2}; + a.delta.add(t1); + a.delta.add(t2); + a.delta.add(t3); + a.delta.add(t4); + a.delta.add(t3); + size_t transitions_cnt{ 0 }; + std::vector expected_transitions{ t1, t2, t3, t4 }; + std::vector iterated_transitions{}; + const Delta::Transitions transitions{ a.delta.transitions() }; + const Delta::Transitions::const_iterator transitions_end{ transitions.end() }; + for (Delta::Transitions::const_iterator trans_it{ transitions.begin()}; trans_it != transitions_end; ++trans_it) { + iterated_transitions.push_back(*trans_it); + ++transitions_cnt; + } + CHECK(transitions_cnt == 4); + CHECK(expected_transitions == iterated_transitions); + + transitions_cnt = 0; + iterated_transitions.clear(); + for (const Transition& trans: a.delta.transitions()) { + iterated_transitions.push_back(trans); + ++transitions_cnt; + } + CHECK(transitions_cnt == 4); + CHECK(expected_transitions == iterated_transitions); + } + +} // }}} + +TEST_CASE("mata::cntnfa::Delta.transform/append") +{ // {{{ + Cntnfa a(3); + a.delta.add(1, 'a', 1); + a.delta.add(2, 'b', {2,1,0}); + + SECTION("transform") + { + auto upd_fnc = [&](State st) { + return st + 5; + }; + std::vector state_posts = a.delta.renumber_targets(upd_fnc); + a.delta.append(state_posts); + + REQUIRE(a.delta.contains(4, 'a', 6)); + REQUIRE(a.delta.contains(5, 'b', 7)); + REQUIRE(a.delta.contains(5, 'b', 5)); + REQUIRE(a.delta.contains(5, 'b', 6)); + } + +} // }}} + +TEST_CASE("mata::cntnfa::is_in_lang_of_counter_nfa() for anbn example") +{ + std::string input = R"(@CNTNFA-explicit + %States q0 q1 q2 q3 + %Alphabet a b + %Initial q0 + %Final q3 + %Registers c0 + q0 a (+ c0 1) q0 + q0 b (= c0 0) q2 + q0 b (= c0 1) (+ c0 -1) q3 + q0 b (> c0 1) (+ c0 -1) q1 + q1 b (> c0 1) (+ c0 -1) q1 + q1 b (= c0 1) (+ c0 -1) q3 + )"; + + auto section = mata::parser::parse_mf_section(input); + OnTheFlyAlphabet alphabet; + Cntnfa aut = builder::construct_counter_nfa(section, &alphabet); + + auto make_word = [&](const std::string& str) -> Word { + Word w; + for (char c : str) + w.push_back(alphabet.translate_symb(std::string(1, c))); + return w; + }; + + SECTION("Should be accepted") { + CHECK(aut.is_in_lang_of_counter_nfa(make_word("ab")) == true); // a^1 b^1 + CHECK(aut.is_in_lang_of_counter_nfa(make_word("aabb")) == true); // a^2 b^2 + CHECK(aut.is_in_lang_of_counter_nfa(make_word("aaabbb")) == true); // a^3 b^3 + CHECK(aut.is_in_lang_of_counter_nfa(make_word("aaaaabbbbb")) == true); // a^5 b^5 + } + + SECTION("Should be rejected") { + CHECK(aut.is_in_lang_of_counter_nfa(make_word("")) == false); // empty input + CHECK(aut.is_in_lang_of_counter_nfa(make_word("a")) == false); // incomplete + CHECK(aut.is_in_lang_of_counter_nfa(make_word("ba")) == false); // wrong order + CHECK(aut.is_in_lang_of_counter_nfa(make_word("bbaa")) == false); // wrong order + } +} + +// TODO: Uncomment when is_counter_nfa_lang_empty() is implemented correctly. +// TEST_CASE("mata::cntnfa::is_counter_nfa_lang_empty()") +// { +// // Cntnfa aut(3); +// // Run cex; + +// SECTION("Empty automaton") +// { +// Cntnfa aut(3); + +// REQUIRE(aut.is_counter_nfa_lang_empty()); +// } + +// SECTION("Automaton with initial and final state but no transitions") +// { +// Cntnfa aut(3); +// Run cex; + +// aut.initial.insert(0); +// aut.final.insert(0); +// REQUIRE_FALSE(aut.is_counter_nfa_lang_empty(&cex)); +// REQUIRE(cex.path == std::vector{0}); +// REQUIRE(cex.word.empty()); +// } + +// SECTION("Automaton with counter increments") +// { +// Cntnfa aut(3); +// Run cex; + +// size_t c0 = aut.counter_set.insert("c0"); +// size_t ann_set = aut.annotation_collection.insert(std::make_shared(c0, 1)); + +// aut.initial.insert(0); +// aut.delta.add(0, 'a', AnnotationState(1, ann_set)); +// aut.final.insert(1); + +// REQUIRE_FALSE(aut.is_counter_nfa_lang_empty(&cex)); +// REQUIRE(cex.word == std::vector{'a'}); +// REQUIRE(cex.path.front() == 0); +// REQUIRE(cex.path.back() == 1); +// } + +// SECTION("Automaton with failing counter test") +// { +// Cntnfa aut(3); +// Run cex; + +// aut.counter_set.clear(); +// size_t c1 = aut.counter_set.insert("c1", 0); +// size_t test_set = aut.annotation_collection.insert(std::make_shared(c1, 1)); + +// aut.initial.insert(0); +// aut.delta.add(0, 'a', AnnotationState(1, test_set)); +// aut.final.insert(1); + +// REQUIRE(aut.is_counter_nfa_lang_empty(&cex)); +// } +// } + +TEST_CASE("mata::cntnfa::is_lang_empty()") +{ // {{{ + Cntnfa aut(14); + Run cex; + + SECTION("An empty automaton has an empty language") + { + REQUIRE(aut.is_lang_empty()); + } + + SECTION("An automaton with a state that is both initial and final does not have an empty language") + { + aut.initial = {1, 2}; + aut.final = {2, 3}; + + bool is_empty = aut.is_lang_empty(&cex); + REQUIRE(!is_empty); + } + + SECTION("More complicated automaton") + { + aut.initial = {1, 2}; + aut.delta.add(1, 'a', 2); + aut.delta.add(1, 'a', 3); + aut.delta.add(1, 'b', 4); + aut.delta.add(2, 'a', 2); + aut.delta.add(2, 'a', 3); + aut.delta.add(2, 'b', 4); + aut.delta.add(3, 'b', 4); + aut.delta.add(3, 'c', 7); + aut.delta.add(3, 'b', 2); + aut.delta.add(7, 'a', 8); + + SECTION("with final states") + { + aut.final = {7}; + REQUIRE(!aut.is_lang_empty()); + } + + SECTION("without final states") + { + REQUIRE(aut.is_lang_empty()); + } + + SECTION("another complicated automaton") + { + FILL_WITH_AUT_A(aut); + + REQUIRE(!aut.is_lang_empty()); + } + + SECTION("a complicated automaton with unreachable final states") + { + FILL_WITH_AUT_A(aut); + aut.final = {13}; + + REQUIRE(aut.is_lang_empty()); + } + } + + SECTION("An automaton with a state that is both initial and final does not have an empty language") + { + aut.initial = {1, 2}; + aut.final = {2, 3}; + + bool is_empty = aut.is_lang_empty(&cex); + REQUIRE(!is_empty); + + // check the counterexample + REQUIRE(cex.path.size() == 1); + REQUIRE(cex.path[0] == 2); + } + + SECTION("Counterexample of an automaton with non-empty language") + { + aut.initial = {1, 2}; + aut.final = {8, 9}; + aut.delta.add(1, 'c', 2); + aut.delta.add(2, 'a', 4); + aut.delta.add(2, 'c', 1); + aut.delta.add(2, 'c', 3); + aut.delta.add(3, 'e', 5); + aut.delta.add(4, 'c', 8); + + bool is_empty = aut.is_lang_empty(&cex); + REQUIRE(!is_empty); + + // check the counterexample + REQUIRE(cex.path.size() == 3); + REQUIRE(cex.path[0] == 2); + REQUIRE(cex.path[1] == 4); + REQUIRE(cex.path[2] == 8); + } +} // }}} + +TEST_CASE("mata::cntnfa::is_acyclic") +{ // {{{ + Cntnfa aut(14); + + SECTION("An empty automaton is acyclic") + { + REQUIRE(aut.is_acyclic()); + } + + SECTION("An automaton with a state that is both initial and final is acyclic") + { + aut.initial = {1, 2}; + aut.final = {2, 3}; + REQUIRE(aut.is_acyclic()); + } + + SECTION("More complicated automaton") + { + aut.initial = {1, 2}; + aut.delta.add(1, 'a', 2); + aut.delta.add(1, 'a', 3); + aut.delta.add(1, 'b', 4); + aut.delta.add(2, 'a', 3); + aut.delta.add(2, 'b', 4); + aut.delta.add(3, 'b', 4); + aut.delta.add(3, 'c', 7); + aut.delta.add(7, 'a', 8); + + SECTION("without final states") + { + REQUIRE(aut.is_lang_empty()); + } + } + + SECTION("Cyclic automaton") + { + aut.initial = {1, 2}; + aut.final = {8, 9}; + aut.delta.add(1, 'c', 2); + aut.delta.add(2, 'a', 4); + aut.delta.add(2, 'c', 1); + aut.delta.add(2, 'c', 3); + aut.delta.add(3, 'e', 5); + aut.delta.add(4, 'c', 8); + REQUIRE(!aut.is_acyclic()); + } + + SECTION("Automaton with self-loops") + { + Cntnfa aut(2); + aut.initial = {0}; + aut.final = {1}; + aut.delta.add(0, 'c', 1); + aut.delta.add(1, 'a', 1); + REQUIRE(!aut.is_acyclic()); + } +} // }}} + +TEST_CASE("mata::cntnfa::is_flat") +{ // {{{ + Cntnfa aut(14); + + SECTION("An empty automaton is flat") + { + REQUIRE(aut.is_flat()); + } + + SECTION("An automaton with a state that is both initial and final is acyclic") + { + aut.initial = {1, 2}; + aut.final = {2, 3}; + REQUIRE(aut.is_flat()); + } + + SECTION("More complicated automaton") + { + aut.initial = {0}; + aut.final = {4}; + aut.delta.add(0, 'a', 1); + aut.delta.add(1, 'a', 3); + aut.delta.add(3, 'b', 2); + aut.delta.add(2, 'a', 1); + aut.delta.add(1, 'b', 4); + aut.delta.add(4, 'b', 6); + aut.delta.add(6, 'c', 5); + aut.delta.add(5, 'a', 4); + REQUIRE(aut.is_flat()); + } + + SECTION("Nonflat automaton") + { + aut.initial = {0}; + aut.final = {4}; + aut.delta.add(0, 'a', 1); + aut.delta.add(1, 'a', 3); + aut.delta.add(3, 'b', 2); + aut.delta.add(2, 'a', 1); + aut.delta.add(1, 'b', 4); + aut.delta.add(4, 'b', 6); + aut.delta.add(6, 'c', 5); + aut.delta.add(5, 'a', 4); + aut.delta.add(1, 'c', 2); + REQUIRE(!aut.is_flat()); + } +} // }}} + +TEST_CASE("mata::cntnfa::get_word_for_path()") +{ // {{{ + Cntnfa aut(5); + Run path; + Word word; + + SECTION("empty word") + { + path = { }; + + auto word_bool_pair = aut.get_word_for_path(path); + REQUIRE(word_bool_pair.second); + REQUIRE(word_bool_pair.first.word.empty()); + } + + SECTION("empty word 2") + { + aut.initial = {1}; + path.path = {1}; + + auto word_bool_pair = aut.get_word_for_path(path); + REQUIRE(word_bool_pair.second); + REQUIRE(word_bool_pair.first.word.empty()); + } + + SECTION("nonempty word") + { + aut.initial = {1}; + aut.delta.add(1, 'c', 2); + aut.delta.add(2, 'a', 4); + aut.delta.add(2, 'c', 1); + aut.delta.add(2, 'b', 3); + + path.path = {1,2,3}; + + auto word_bool_pair = aut.get_word_for_path(path); + REQUIRE(word_bool_pair.second); + REQUIRE(word_bool_pair.first.word == Word({'c', 'b'})); + } + + SECTION("longer word") + { + aut.initial = {1}; + aut.delta.add(1, 'a', 2); + aut.delta.add(1, 'c', 2); + aut.delta.add(2, 'a', 4); + aut.delta.add(2, 'c', 1); + aut.delta.add(2, 'b', 3); + aut.delta.add(3, 'd', 2); + + path.path = {1,2,3,2,4}; + + auto word_bool_pair = aut.get_word_for_path(path); + std::set possible({ + Word({'c', 'b', 'd', 'a'}), + Word({'a', 'b', 'd', 'a'})}); + REQUIRE(word_bool_pair.second); + REQUIRE(haskey(possible, word_bool_pair.first.word)); + } + + SECTION("invalid path") + { + aut.initial = {1}; + aut.delta.add(1, 'a', 2); + aut.delta.add(1, 'c', 2); + aut.delta.add(2, 'a', 4); + aut.delta.add(2, 'c', 1); + aut.delta.add(2, 'b', 3); + aut.delta.add(3, 'd', 2); + + path.path = {1,2,3,1,2}; + + auto word_bool_pair = aut.get_word_for_path(path); + REQUIRE(!word_bool_pair.second); + } +} + + +TEST_CASE("mata::cntnfa::is_lang_empty_cex()") +{ + Cntnfa aut(10); + Run cex; + + SECTION("Counterexample of an automaton with non-empty language") + { + aut.initial = {1, 2}; + aut.final = {8, 9}; + aut.delta.add(1, 'c', 2); + aut.delta.add(2, 'a', 4); + aut.delta.add(2, 'c', 1); + aut.delta.add(2, 'c', 3); + aut.delta.add(3, 'e', 5); + aut.delta.add(4, 'c', 8); + + bool is_empty = aut.is_lang_empty(&cex); + REQUIRE(!is_empty); + + // check the counterexample + REQUIRE(cex.word.size() == 2); + REQUIRE(cex.word[0] == 'a'); + REQUIRE(cex.word[1] == 'c'); + } +} + +TEST_CASE("mata::cntnfa::determinize()") +{ + Cntnfa aut(3); + Cntnfa result; + std::unordered_map subset_map; + + SECTION("empty automaton") + { + result = determinize(aut); + + REQUIRE(result.final.empty()); + REQUIRE(result.delta.empty()); + CHECK(result.is_lang_empty()); + } + + SECTION("simple automaton 1") + { + aut.initial = {1 }; + aut.final = {1 }; + result = determinize(aut, &subset_map); + + REQUIRE(result.initial[subset_map[{1}]]); + REQUIRE(result.final[subset_map[{1}]]); + REQUIRE(result.delta.empty()); + } + + SECTION("simple automaton 2") + { + aut.initial = {1 }; + aut.final = {2 }; + aut.delta.add(1, 'a', 2); + result = determinize(aut, &subset_map); + + REQUIRE(result.initial[subset_map[{1}]]); + REQUIRE(result.final[subset_map[{2}]]); + REQUIRE(result.delta.contains(subset_map[{1}], 'a', subset_map[{2}])); + } + + SECTION("This broke Delta when delta[q] could cause re-allocation of post") + { + Cntnfa x{}; + x.initial.insert(0); + x.final.insert(4); + x.delta.add(0, 1, 3); + x.delta.add(3, 1, 3); + x.delta.add(3, 2, 3); + x.delta.add(3, 0, 1); + x.delta.add(1, 1, 1); + x.delta.add(1, 2, 1); + x.delta.add(1, 0, 2); + x.delta.add(2, 0, 2); + x.delta.add(2, 1, 2); + x.delta.add(2, 2, 2); + x.delta.add(2, 0, 4); + OnTheFlyAlphabet alphabet{}; + auto complement_result{determinize(x)}; + } +} // }}} + +TEST_CASE("mata::cntnfa::Cntnfa::get_word_from_complement()") { + Cntnfa aut{}; + std::optional result; + std::unordered_map subset_map; + EnumAlphabet alphabet{ 'a', 'b', 'c' }; + + SECTION("empty automaton") { + result = aut.get_word_from_complement(); + REQUIRE(result.has_value()); + CHECK(*result == Word{}); + } + + SECTION("empty automaton 2") { + aut.initial = { 0 }; + result = aut.get_word_from_complement(); + REQUIRE(result.has_value()); + CHECK(*result == Word{}); + } + + SECTION("empty automaton 3") { + aut.initial = { 0 }; + aut.final = { 1 }; + result = aut.get_word_from_complement(); + REQUIRE(result.has_value()); + CHECK(*result == Word{}); + } + + SECTION("simple automaton 1") { + aut.initial = { 0 }; + aut.final = { 0 }; + result = aut.get_word_from_complement(&alphabet); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 'a' }); + } + + SECTION("simple automaton 2") { + aut.initial = { 0 }; + aut.final = { 1 }; + aut.delta.add(0, 'a', 1); + result = aut.get_word_from_complement(); + REQUIRE(result.has_value()); + CHECK(*result == Word{}); + } + + SECTION("simple automaton 2 with epsilon") { + aut.alphabet = &alphabet; + aut.initial = { 0 }; + aut.final = { 0, 1 }; + aut.delta.add(0, 'a', 1); + result = aut.get_word_from_complement(); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 'b' }); + } + + SECTION("nfa accepting \\eps+a+b+c") { + aut.alphabet = &alphabet; + aut.initial = { 0 }; + aut.final = { 0, 1 }; + aut.delta.add(0, 'a', 1); + aut.delta.add(0, 'b', 1); + aut.delta.add(0, 'c', 1); + result = aut.get_word_from_complement(); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 'a', 'a' }); + } + + SECTION("nfa accepting \\eps+a+b+c+aa") { + aut.initial = { 0 }; + aut.final = { 0, 1 }; + aut.delta.add(0, 'a', 1); + aut.delta.add(0, 'b', 1); + aut.delta.add(0, 'c', 1); + result = aut.get_word_from_complement(); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 'a', 'a' }); + } + + SECTION("simple automaton 3") { + aut.initial = { 1 }; + aut.final = { 1, 2, 3, 4, 5 }; + aut.delta.add(1, 'a', 2); + aut.delta.add(2, 'a', 3); + aut.delta.add(2, 'a', 6); + aut.delta.add(6, 'a', 6); + aut.delta.add(3, 'a', 4); + aut.delta.add(4, 'a', 5); + result = aut.get_word_from_complement(); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 'a', 'a','a', 'a', 'a' }); + } + + SECTION("universal language") { + aut.initial = { 1 }; + aut.final = { 1 }; + aut.delta.add(1, 'a', 1); + result = aut.get_word_from_complement(); + CHECK(!result.has_value()); + } + + SECTION("smaller alphabet symbol") { + aut.initial = { 1 }; + aut.final = { 1 }; + aut.delta.add(1, 'b', 1); + result = aut.get_word_from_complement(&alphabet); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 'a' }); + } + + SECTION("smaller transition symbol") { + aut.initial = { 1 }; + aut.final = { 1 }; + aut.delta.add(1, 'a', 1); + aut.delta.add(1, 0, 2); + result = aut.get_word_from_complement(&alphabet); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 0 }); + } + + SECTION("smaller transition symbol 2") { + aut.initial = { 1 }; + aut.final = { 1 }; + aut.delta.add(1, 0, 2); + result = aut.get_word_from_complement(&alphabet); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 0 }); + } +} + +TEST_CASE("mata::cntnfa::lang_difference()") { + Cntnfa nfa_included{}; + Cntnfa nfa_excluded{}; + Cntnfa result{}; + Cntnfa expected{}; + + SECTION("empty automata") { + result = lang_difference(nfa_included, nfa_excluded); + CHECK(result.is_lang_empty()); + } + + SECTION("empty included") { + nfa_excluded.initial = { 0 }; + nfa_excluded.final = { 0 }; + result = lang_difference(nfa_included, nfa_excluded); + CHECK(result.is_lang_empty()); + } + + SECTION("empty excluded") { + nfa_included.initial = { 0 }; + nfa_included.final = { 0 }; + result = lang_difference(nfa_included, nfa_excluded); + expected = nfa_included; + CHECK(are_equivalent(result, expected)); + } + + SECTION("included { '', 'a' }, excluded { '' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.final = { 0, 1 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.final = { 0 }; + + expected.initial = { 0 }; + expected.delta.add(0, 'a', 1); + expected.final = { 1 }; + + result = lang_difference(nfa_included, nfa_excluded); + CHECK(are_equivalent(result, expected)); + } + + SECTION("included { '', 'a' }, excluded { 'a' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.final = { 0 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.final = { 1 }; + + expected.initial = { 0 }; + expected.final = { 0 }; + + result = lang_difference(nfa_included, nfa_excluded); + CHECK(are_equivalent(result, expected)); + } + + SECTION("included { '', 'a' }, excluded { '', 'a' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.final = { 0, 1 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.final = { 0, 1 }; + + result = lang_difference(nfa_included, nfa_excluded); + CHECK(are_equivalent(result, expected)); + } + + SECTION("included { '', 'a', 'ab' }, excluded { '', 'ab' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.delta.add(1, 'b', 2); + nfa_included.final = { 0, 1, 2 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.delta.add(1, 'b', 2); + nfa_excluded.final = { 0, 2 }; + + expected.initial = { 0 }; + expected.delta.add(0, 'a', 1); + expected.final = { 1 }; + + result = lang_difference(nfa_included, nfa_excluded); + CHECK(are_equivalent(result, expected)); + } + + SECTION("included { '', 'a+', 'a+b' }, excluded { '', 'ab' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.delta.add(1, 'a', 1); + nfa_included.delta.add(1, 'b', 2); + nfa_included.final = { 0, 1, 2 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.delta.add(1, 'b', 2); + nfa_excluded.final = { 0, 2 }; + + expected.initial = { 0 }; + expected.delta.add(0, 'a', 1); + expected.delta.add(1, 'a', 1); + expected.delta.add(1, 'a', 2); + expected.delta.add(2, 'b', 3); + expected.final = { 1, 3 }; + + result = lang_difference(nfa_included, nfa_excluded); + CHECK(are_equivalent(result, expected)); + } + + SECTION("included { '', 'ab' }, excluded { '', 'a+', 'a+b' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.delta.add(1, 'b', 2); + nfa_included.final = { 0, 2 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.delta.add(1, 'a', 1); + nfa_excluded.delta.add(1, 'b', 2); + nfa_excluded.final = { 0, 1, 2 }; + + result = lang_difference(nfa_included, nfa_excluded); + CHECK(are_equivalent(result, expected)); + } + + SECTION("included { 'a', 'ab', '(abc)+a', '(abc)+ab' }, excluded { 'a', 'ab' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.delta.add(0, 'a', 2); + nfa_included.delta.add(0, 'a', 3); + nfa_included.delta.add(3, 'b', 4); + nfa_included.delta.add(2, 'b', 5); + nfa_included.delta.add(1, 'b', 6); + nfa_included.delta.add(6, 'c', 0); + nfa_included.final = { 2, 6 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.delta.add(1, 'b', 2); + nfa_excluded.final = { 0, 1, 2 }; + + expected.initial = { 0 }; + expected.delta.add(0, 'a', 1); + expected.delta.add(1, 'b', 2); + expected.delta.add(2, 'c', 3); + expected.delta.add(3, 'a', 4); + expected.delta.add(4, 'b', 5); + expected.delta.add(5, 'c', 3); + expected.final = { 4, 5 }; + + result = lang_difference(nfa_included, nfa_excluded); + CHECK(are_equivalent(result, expected)); + } +} + +TEST_CASE("mata::cntnfa::Cntnfa::get_word_from_lang_difference()") { + Cntnfa nfa_included{}; + Cntnfa nfa_excluded{}; + std::optional result{}; + Cntnfa expected{}; + + SECTION("empty automata") { + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + CHECK(!result.has_value()); + } + + SECTION("empty included") { + nfa_excluded.initial = { 0 }; + nfa_excluded.final = { 0 }; + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + CHECK(!result.has_value()); + } + + SECTION("empty excluded") { + nfa_included.initial = { 0 }; + nfa_included.final = { 0 }; + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + REQUIRE(result.has_value()); + CHECK(*result == Word{}); + } + + SECTION("included { '', 'a' }, excluded { '' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.final = { 0, 1 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.final = { 0 }; + + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 'a' }); + } + + SECTION("included { '', 'a' }, excluded { 'a' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.final = { 0 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.final = { 1 }; + + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + REQUIRE(result.has_value()); + CHECK(*result == Word{}); + } + + SECTION("included { '', 'a' }, excluded { '', 'a' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.final = { 0, 1 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.final = { 0, 1 }; + + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + CHECK(!result.has_value()); + } + + SECTION("included { '', 'a', 'ab' }, excluded { '', 'ab' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.delta.add(1, 'b', 2); + nfa_included.final = { 0, 1, 2 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.delta.add(1, 'b', 2); + nfa_excluded.final = { 0, 2 }; + + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + REQUIRE(result.has_value()); + CHECK(*result == Word{ 'a' }); + } + + SECTION("included { '', 'a+', 'a+b' }, excluded { '', 'ab' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.delta.add(1, 'a', 1); + nfa_included.delta.add(1, 'b', 2); + nfa_included.final = { 0, 1, 2 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.delta.add(1, 'b', 2); + nfa_excluded.final = { 0, 2 }; + + expected.initial = { 0 }; + expected.delta.add(0, 'a', 1); + expected.delta.add(1, 'a', 1); + expected.delta.add(1, 'a', 2); + expected.delta.add(2, 'b', 3); + expected.final = { 1, 3 }; + + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + REQUIRE(result.has_value()); + CHECK(expected.is_in_lang(*result)); + } + + SECTION("included { '', 'ab' }, excluded { '', 'a+', 'a+b' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.delta.add(1, 'b', 2); + nfa_included.final = { 0, 2 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.delta.add(1, 'a', 1); + nfa_excluded.delta.add(1, 'b', 2); + nfa_excluded.final = { 0, 1, 2 }; + + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + CHECK(!result.has_value()); + } + + SECTION("included { 'a', 'ab', '(abc)+a', '(abc)+ab' }, excluded { 'a', 'ab' }") { + nfa_included.initial = { 0 }; + nfa_included.delta.add(0, 'a', 1); + nfa_included.delta.add(0, 'a', 2); + nfa_included.delta.add(0, 'a', 3); + nfa_included.delta.add(3, 'b', 4); + nfa_included.delta.add(2, 'b', 5); + nfa_included.delta.add(1, 'b', 6); + nfa_included.delta.add(6, 'c', 0); + nfa_included.final = { 2, 6 }; + + nfa_excluded.initial = { 0 }; + nfa_excluded.delta.add(0, 'a', 1); + nfa_excluded.delta.add(1, 'b', 2); + nfa_excluded.final = { 0, 1, 2 }; + + expected.initial = { 0 }; + expected.delta.add(0, 'a', 1); + expected.delta.add(1, 'b', 2); + expected.delta.add(2, 'c', 3); + expected.delta.add(3, 'a', 4); + expected.delta.add(4, 'b', 5); + expected.delta.add(5, 'c', 3); + expected.final = { 4, 5 }; + + result = get_word_from_lang_difference(nfa_included, nfa_excluded); + REQUIRE(result.has_value()); + CHECK(expected.is_in_lang(*result)); + } +} + +TEST_CASE("mata::cntnfa::minimize() for profiling", "[.profiling],[minimize]") { + Cntnfa aut(4); + Cntnfa result; + std::unordered_map subset_map; + + aut.initial.insert(0); + aut.final.insert(3); + aut.delta.add(0, 46, 0); + aut.delta.add(0, 47, 0); + aut.delta.add(0, 58, 0); + aut.delta.add(0, 58, 1); + aut.delta.add(0, 64, 0); + aut.delta.add(0, 64, 0); + aut.delta.add(0, 82, 0); + aut.delta.add(0, 92, 0); + aut.delta.add(0, 98, 0); + aut.delta.add(0, 100, 0); + aut.delta.add(0, 103, 0); + aut.delta.add(0, 109, 0); + aut.delta.add(0, 110, 0); + aut.delta.add(0, 111, 0); + aut.delta.add(0, 114, 0); + aut.delta.add(1, 47, 2); + aut.delta.add(2, 47, 3); + aut.delta.add(3, 46, 3); + aut.delta.add(3, 47, 3); + aut.delta.add(3, 58, 3); + aut.delta.add(3, 64, 3); + aut.delta.add(3, 82, 3); + aut.delta.add(3, 92, 3); + aut.delta.add(3, 98, 3); + aut.delta.add(3, 100, 3); + aut.delta.add(3, 103, 3); + aut.delta.add(3, 109, 3); + aut.delta.add(3, 110, 3); + aut.delta.add(3, 111, 3); + aut.delta.add(3, 114, 3); + minimize(&result, aut); +} + +TEST_CASE("mata::cntnfa::construct() correct calls") +{ // {{{ + Cntnfa aut(10); + mata::parser::ParsedSection parsec; + OnTheFlyAlphabet alphabet; + + SECTION("construct an empty automaton") + { + parsec.type = cntnfa::TYPE_CNTNFA; + + aut = builder::construct(parsec); + + REQUIRE(aut.is_lang_empty()); + } + + SECTION("construct a simple non-empty automaton accepting the empty word") + { + parsec.type = cntnfa::TYPE_CNTNFA; + parsec.dict.insert({"Initial", {"q1"}}); + parsec.dict.insert({"Final", {"q1"}}); + + aut = builder::construct(parsec); + + REQUIRE(!aut.is_lang_empty()); + } + + SECTION("construct an automaton with more than one initial/final states") + { + parsec.type = cntnfa::TYPE_CNTNFA; + parsec.dict.insert({"Initial", {"q1", "q2"}}); + parsec.dict.insert({"Final", {"q1", "q2", "q3"}}); + + aut = builder::construct(parsec); + + REQUIRE(aut.initial.size() == 2); + REQUIRE(aut.final.size() == 3); + } + + SECTION("construct a simple non-empty automaton accepting only the word 'a'") + { + parsec.type = cntnfa::TYPE_CNTNFA; + parsec.dict.insert({"Initial", {"q1"}}); + parsec.dict.insert({"Final", {"q2"}}); + parsec.body = { {"q1", "a", "q2"} }; + + aut = builder::construct(parsec, &alphabet); + + Run cex; + REQUIRE(!aut.is_lang_empty(&cex)); + auto word_bool_pair = aut.get_word_for_path(cex); + REQUIRE(word_bool_pair.second); + REQUIRE(word_bool_pair.first.word == encode_word(&alphabet, { "a"}).word); + + REQUIRE(aut.is_in_lang(encode_word(&alphabet, { "a"}))); + } + + SECTION("construct a more complicated non-empty automaton") + { + parsec.type = cntnfa::TYPE_CNTNFA; + parsec.dict.insert({"Initial", {"q1", "q3"}}); + parsec.dict.insert({"Final", {"q5"}}); + parsec.body.push_back({"q1", "a", "q3"}); + parsec.body.push_back({"q1", "a", "q10"}); + parsec.body.push_back({"q1", "b", "q7"}); + parsec.body.push_back({"q3", "a", "q7"}); + parsec.body.push_back({"q3", "b", "q9"}); + parsec.body.push_back({"q9", "a", "q9"}); + parsec.body.push_back({"q7", "b", "q1"}); + parsec.body.push_back({"q7", "a", "q3"}); + parsec.body.push_back({"q7", "c", "q3"}); + parsec.body.push_back({"q10", "a", "q7"}); + parsec.body.push_back({"q10", "b", "q7"}); + parsec.body.push_back({"q10", "c", "q7"}); + parsec.body.push_back({"q7", "a", "q5"}); + parsec.body.push_back({"q5", "a", "q5"}); + parsec.body.push_back({"q5", "c", "q9"}); + + aut = builder::construct(parsec, &alphabet); + + // some samples + REQUIRE(aut.is_in_lang(encode_word(&alphabet, { "b", "a"}))); + REQUIRE(aut.is_in_lang(encode_word(&alphabet, { "a", "c", "a", "a"}))); + REQUIRE(aut.is_in_lang(encode_word(&alphabet, + {"a", "a", "a", "a", "a", "a", "a", "a", "a", "a", "a", "a"}))); + // some wrong samples + REQUIRE(!aut.is_in_lang(encode_word(&alphabet, { "b", "c"}))); + REQUIRE(!aut.is_in_lang(encode_word(&alphabet, { "a", "c", "c", "a"}))); + REQUIRE(!aut.is_in_lang(encode_word(&alphabet, { "b", "a", "c", "b"}))); + } +} // }}} + +TEST_CASE("mata::cntnfa::construct() invalid calls") +{ // {{{ + Cntnfa aut; + mata::parser::ParsedSection parsec; + + SECTION("construct() call with invalid ParsedSection object") + { + parsec.type = "FA"; + + CHECK_THROWS_WITH(builder::construct(parsec), + Catch::Matchers::ContainsSubstring("expecting type")); + } + + SECTION("construct() call with an epsilon transition") + { + parsec.type = cntnfa::TYPE_CNTNFA; + parsec.body = { {"q1", "q2"} }; + + CHECK_THROWS_WITH(builder::construct(parsec), + Catch::Matchers::ContainsSubstring("Epsilon transition")); + } + + SECTION("construct() call with a nonsense transition") + { + parsec.type = cntnfa::TYPE_CNTNFA; + parsec.body = { {"q1", "a", "q2", "q3"} }; + + CHECK_THROWS_WITH(plumbing::construct(&aut, parsec), + Catch::Matchers::ContainsSubstring("Invalid transition")); + } +} // }}} + +TEST_CASE("mata::cntnfa::construct() from IntermediateAut correct calls") +{ // {{{ + Cntnfa aut; + mata::IntermediateAut inter_aut; + OnTheFlyAlphabet alphabet; + + SECTION("construct an empty automaton") + { + inter_aut.automaton_type = mata::IntermediateAut::AutomatonType::NFA; + REQUIRE(aut.is_lang_empty()); + aut = builder::construct(inter_aut); + REQUIRE(aut.is_lang_empty()); + } + + SECTION("construct a simple non-empty automaton accepting the empty word from intermediate automaton") + { + std::string file = + "@NFA-explicit\n" + "%States-enum p q r\n" + "%Alphabet-auto\n" + "%Initial p | q\n" + "%Final p | q\n"; + const auto auts = mata::IntermediateAut::parse_from_mf(parse_mf(file)); + inter_aut = auts[0]; + + aut = builder::construct(inter_aut); + + REQUIRE(!aut.is_lang_empty()); + } + + SECTION("construct an automaton with more than one initial/final states from intermediate automaton") + { + std::string file = + "@NFA-explicit\n" + "%States-enum p q 3\n" + "%Alphabet-auto\n" + "%Initial p | q\n" + "%Final p | q | r\n"; + const auto auts = mata::IntermediateAut::parse_from_mf(parse_mf(file)); + inter_aut = auts[0]; + + plumbing::construct(&aut, inter_aut); + + REQUIRE(aut.initial.size() == 2); + REQUIRE(aut.final.size() == 3); + } + + SECTION("construct an automaton with implicit operator completion one initial/final states from intermediate automaton") + { + std::string file = + "@NFA-explicit\n" + "%States-enum p q r\n" + "%Alphabet-auto\n" + "%Initial p q\n" + "%Final p q r\n"; + const auto auts = mata::IntermediateAut::parse_from_mf(parse_mf(file)); + inter_aut = auts[0]; + + plumbing::construct(&aut, inter_aut); + + REQUIRE(aut.initial.size() == 2); + REQUIRE(aut.final.size() == 3); + } + + SECTION("construct an automaton with implicit operator completion one initial/final states from intermediate automaton") + { + std::string file = + "@NFA-explicit\n" + "%States-enum p q r m n\n" + "%Alphabet-auto\n" + "%Initial p q r\n" + "%Final p q m n\n"; + const auto auts = mata::IntermediateAut::parse_from_mf(parse_mf(file)); + inter_aut = auts[0]; + + plumbing::construct(&aut, inter_aut); + + REQUIRE(aut.initial.size() == 3); + REQUIRE(aut.final.size() == 4); + } + + SECTION("construct a simple non-empty automaton accepting only the word 'a' from intermediate automaton") + { + std::string file = + "@NFA-explicit\n" + "%States-enum p q 3\n" + "%Alphabet-auto\n" + "%Initial q1\n" + "%Final q2\n" + "q1 a q2\n"; + + const auto auts = mata::IntermediateAut::parse_from_mf(parse_mf(file)); + inter_aut = auts[0]; + plumbing::construct(&aut, inter_aut, &alphabet); + + Run cex; + REQUIRE(!aut.is_lang_empty(&cex)); + auto word_bool_pair = aut.get_word_for_path(cex); + REQUIRE(word_bool_pair.second); + REQUIRE(word_bool_pair.first.word == encode_word(&alphabet, { "a" }).word); + + REQUIRE(aut.is_in_lang(encode_word(&alphabet, { "a" }))); + } + + SECTION("construct a more complicated non-empty automaton from intermediate automaton") + { + std::string file = + "@NFA-explicit\n" + "%States-enum p q 3\n" + "%Alphabet-auto\n" + "%Initial q1 | q3\n" + "%Final q5\n" + "q1 a q3\n" + "q1 a q10\n" + "q1 b q7\n" + "q3 a q7\n" + "q3 b q9\n" + "q9 a q9\n" + "q7 b q1\n" + "q7 a q3\n" + "q7 c q3\n" + "q10 a q7\n" + "q10 b q7\n" + "q10 c q7\n" + "q7 a q5\n" + "q5 c q9\n"; + + const auto auts = mata::IntermediateAut::parse_from_mf(parse_mf(file)); + inter_aut = auts[0]; + + plumbing::construct(&aut, inter_aut, &alphabet); + + // some samples + REQUIRE(aut.is_in_lang(encode_word(&alphabet, { "b", "a"}))); + REQUIRE(aut.is_in_lang(encode_word(&alphabet, { "a", "c", "a", "a"}))); + REQUIRE(aut.is_in_lang(encode_word(&alphabet, + {"a", "a", "a", "a", "a", "a", "a", "a", "a", "a", "a", "a"}))); + // some wrong samples + REQUIRE(!aut.is_in_lang(encode_word(&alphabet, { "b", "c"}))); + REQUIRE(!aut.is_in_lang(encode_word(&alphabet, { "a", "c", "c", "a"}))); + REQUIRE(!aut.is_in_lang(encode_word(&alphabet, { "b", "a", "c", "b"}))); + } + + SECTION("construct - final states from negation") + { + std::string file = + "@NFA-bits\n" + "%Alphabet-auto\n" + "%Initial q0 q8\n" + "%Final !q0 & !q1 & !q4 & !q5 & !q6\n" + "q0 a1 q1\n" + "q1 a2 q2\n" + "q2 a3 q3\n" + "q2 a4 q4\n" + "q3 a5 q5\n" + "q3 a6 q6\n" + "q5 a7 q7\n"; + + const auto auts = mata::IntermediateAut::parse_from_mf(parse_mf(file)); + inter_aut = auts[0]; + + plumbing::construct(&aut, inter_aut, &alphabet); + REQUIRE(aut.final.size() == 4); + REQUIRE(aut.is_in_lang(encode_word(&alphabet, { "a1", "a2"}))); + REQUIRE(aut.is_in_lang(encode_word(&alphabet, { "a1", "a2", "a3"}))); + REQUIRE(!aut.is_in_lang(encode_word(&alphabet, { "a1", "a2", "a3", "a4"}))); + REQUIRE(aut.is_in_lang(encode_word(&alphabet, { "a1", "a2", "a3", "a5", "a7"}))); + } + + SECTION("construct - final states given as true") + { + std::string file = + "@NFA-bits\n" + "%Alphabet-auto\n" + "%Initial q0 q8\n" + "%Final \\true\n" + "q0 a1 q1\n" + "q1 a2 q2\n" + "q2 a3 q3\n" + "q2 a4 q4\n" + "q3 a5 q5\n" + "q3 a6 q6\n" + "q5 a7 q7\n"; + + const auto auts = mata::IntermediateAut::parse_from_mf(parse_mf(file)); + inter_aut = auts[0]; + + cntnfa::builder::NameStateMap state_map; + plumbing::construct(&aut, inter_aut, &alphabet, &state_map); + CHECK(aut.final.size() == 9); + CHECK(aut.final[state_map.at("0")]); + CHECK(aut.final[state_map.at("1")]); + CHECK(aut.final[state_map.at("2")]); + CHECK(aut.final[state_map.at("3")]); + CHECK(aut.final[state_map.at("4")]); + CHECK(aut.final[state_map.at("5")]); + CHECK(aut.final[state_map.at("6")]); + CHECK(aut.final[state_map.at("7")]); + CHECK(aut.final[state_map.at("8")]); + } + + SECTION("construct - final states given as false") + { + std::string file = + "@NFA-bits\n" + "%Alphabet-auto\n" + "%Initial q0 q8\n" + "%Final \\false\n" + "q0 a1 q1\n" + "q1 a2 q2\n" + "q2 a3 q3\n" + "q2 a4 q4\n" + "q3 a5 q5\n" + "q3 a6 q6\n" + "q5 a7 q7\n"; + + const auto auts = mata::IntermediateAut::parse_from_mf(parse_mf(file)); + inter_aut = auts[0]; + + cntnfa::builder::NameStateMap state_map; + plumbing::construct(&aut, inter_aut, &alphabet, &state_map); + CHECK(aut.final.empty()); + } +} // }}} + +TEST_CASE("mata::cntnfa::make_complete()") +{ // {{{ + Cntnfa aut{}; + + SECTION("empty automaton, empty alphabet") + { + OnTheFlyAlphabet alph{}; + + aut.make_complete(&alph, 0); + + REQUIRE(aut.initial.empty()); + REQUIRE(aut.final.empty()); + REQUIRE(aut.delta.empty()); + } + + SECTION("empty automaton") + { + OnTheFlyAlphabet alph{ std::vector{ "a", "b" } }; + + aut.make_complete(&alph, 0); + + CHECK(aut.initial.empty()); + CHECK(aut.final.empty()); + CHECK(!aut.delta.contains(0, alph["a"], 0)); + CHECK(!aut.delta.contains(0, alph["b"], 0)); + } + + SECTION("non-empty automaton, empty alphabet") + { + OnTheFlyAlphabet alphabet{}; + + aut.initial = {1}; + + aut.make_complete(&alphabet, 0); + + CHECK(aut.initial.size() == 1); + CHECK(*aut.initial.begin() == 1); + CHECK(aut.final.empty()); + CHECK(aut.delta.empty()); + } + + SECTION("one-state automaton") + { + OnTheFlyAlphabet alph{ std::vector{ "a", "b" } }; + const State SINK = 10; + + aut.initial = {1}; + + aut.make_complete(&alph, SINK); + + CHECK(aut.initial.size() == 1); + CHECK(*aut.initial.begin() == 1); + CHECK(aut.final.empty()); + CHECK(aut.delta.contains(1, alph["a"], SINK)); + CHECK(aut.delta.contains(1, alph["b"], SINK)); + CHECK(aut.delta.contains(SINK, alph["a"], SINK)); + CHECK(aut.delta.contains(SINK, alph["b"], SINK)); + } + + SECTION("bigger automaton") + { + OnTheFlyAlphabet alph{ std::vector{ "a", "b", "c" } }; + const State SINK = 9; + + aut.initial = {1, 2}; + aut.final = {8}; + aut.delta.add(1, alph["a"], 2); + aut.delta.add(2, alph["a"], 4); + aut.delta.add(2, alph["c"], 1); + aut.delta.add(2, alph["c"], 3); + aut.delta.add(3, alph["b"], 5); + aut.delta.add(4, alph["c"], 8); + + aut.make_complete(&alph, SINK); + + CHECK(aut.delta.contains(1, alph["a"], 2)); + CHECK(aut.delta.contains(1, alph["b"], SINK)); + CHECK(aut.delta.contains(1, alph["c"], SINK)); + CHECK(aut.delta.contains(2, alph["a"], 4)); + CHECK(aut.delta.contains(2, alph["c"], 1)); + CHECK(aut.delta.contains(2, alph["c"], 3)); + CHECK(aut.delta.contains(2, alph["b"], SINK)); + CHECK(aut.delta.contains(3, alph["b"], 5)); + CHECK(aut.delta.contains(3, alph["a"], SINK)); + CHECK(aut.delta.contains(3, alph["c"], SINK)); + CHECK(aut.delta.contains(4, alph["c"], 8)); + CHECK(aut.delta.contains(4, alph["a"], SINK)); + CHECK(aut.delta.contains(4, alph["b"], SINK)); + CHECK(aut.delta.contains(5, alph["a"], SINK)); + CHECK(aut.delta.contains(5, alph["b"], SINK)); + CHECK(aut.delta.contains(5, alph["c"], SINK)); + CHECK(aut.delta.contains(8, alph["a"], SINK)); + CHECK(aut.delta.contains(8, alph["b"], SINK)); + CHECK(aut.delta.contains(8, alph["c"], SINK)); + CHECK(aut.delta.contains(SINK, alph["a"], SINK)); + CHECK(aut.delta.contains(SINK, alph["b"], SINK)); + CHECK(aut.delta.contains(SINK, alph["c"], SINK)); + } + + SECTION("bigger automaton parameters from automaton with alphabet") { + constexpr State SINK = 9; + aut.initial = {1, 2}; + aut.final = {8}; + aut.delta.add(1, 'a', 2); + aut.delta.add(2, 'a', 4); + aut.delta.add(2, 'c', 1); + aut.delta.add(2, 'c', 3); + aut.delta.add(3, 'b', 5); + aut.delta.add(4, 'c', 8); + EnumAlphabet alphabet{ 'a', 'b', 'c' }; + aut.alphabet = &alphabet; + + aut.make_complete(); + CHECK(aut.delta.contains(1, 'a', 2)); + CHECK(aut.delta.contains(1, 'b', SINK)); + CHECK(aut.delta.contains(1, 'c', SINK)); + CHECK(aut.delta.contains(2, 'a', 4)); + CHECK(aut.delta.contains(2, 'c', 1)); + CHECK(aut.delta.contains(2, 'c', 3)); + CHECK(aut.delta.contains(2, 'b', SINK)); + CHECK(aut.delta.contains(3, 'b', 5)); + CHECK(aut.delta.contains(3, 'a', SINK)); + CHECK(aut.delta.contains(3, 'c', SINK)); + CHECK(aut.delta.contains(4, 'c', 8)); + CHECK(aut.delta.contains(4, 'a', SINK)); + CHECK(aut.delta.contains(4, 'b', SINK)); + CHECK(aut.delta.contains(5, 'a', SINK)); + CHECK(aut.delta.contains(5, 'b', SINK)); + CHECK(aut.delta.contains(5, 'c', SINK)); + CHECK(aut.delta.contains(8, 'a', SINK)); + CHECK(aut.delta.contains(8, 'b', SINK)); + CHECK(aut.delta.contains(8, 'c', SINK)); + CHECK(aut.delta.contains(SINK, 'a', SINK)); + CHECK(aut.delta.contains(SINK, 'b', SINK)); + CHECK(aut.delta.contains(SINK, 'c', SINK)); + } + + SECTION("bigger automaton parameters from automaton") { + constexpr State SINK = 9; + aut.initial = {1, 2}; + aut.final = {8}; + aut.delta.add(1, 'a', 2); + aut.delta.add(2, 'a', 4); + aut.delta.add(2, 'c', 1); + aut.delta.add(2, 'c', 3); + aut.delta.add(3, 'b', 5); + aut.delta.add(4, 'c', 8); + + aut.make_complete(); + CHECK(aut.delta.contains(1, 'a', 2)); + CHECK(aut.delta.contains(1, 'b', SINK)); + CHECK(aut.delta.contains(1, 'c', SINK)); + CHECK(aut.delta.contains(2, 'a', 4)); + CHECK(aut.delta.contains(2, 'c', 1)); + CHECK(aut.delta.contains(2, 'c', 3)); + CHECK(aut.delta.contains(2, 'b', SINK)); + CHECK(aut.delta.contains(3, 'b', 5)); + CHECK(aut.delta.contains(3, 'a', SINK)); + CHECK(aut.delta.contains(3, 'c', SINK)); + CHECK(aut.delta.contains(4, 'c', 8)); + CHECK(aut.delta.contains(4, 'a', SINK)); + CHECK(aut.delta.contains(4, 'b', SINK)); + CHECK(aut.delta.contains(5, 'a', SINK)); + CHECK(aut.delta.contains(5, 'b', SINK)); + CHECK(aut.delta.contains(5, 'c', SINK)); + CHECK(aut.delta.contains(8, 'a', SINK)); + CHECK(aut.delta.contains(8, 'b', SINK)); + CHECK(aut.delta.contains(8, 'c', SINK)); + CHECK(aut.delta.contains(SINK, 'a', SINK)); + CHECK(aut.delta.contains(SINK, 'b', SINK)); + CHECK(aut.delta.contains(SINK, 'c', SINK)); + } +} // }}} + +TEST_CASE("mata::cntnfa::complement()") +{ // {{{ + Cntnfa aut(3); + Cntnfa cmpl; + + SECTION("empty automaton, empty alphabet") + { + OnTheFlyAlphabet alph{}; + + cmpl = complement(aut, alph, { {"algorithm", "classical"} }); + Cntnfa empty_string_nfa{ cntnfa::builder::create_sigma_star_nfa(&alph) }; + CHECK(are_equivalent(cmpl, empty_string_nfa)); + } + + SECTION("empty automaton") + { + OnTheFlyAlphabet alph{ std::vector{ "a", "b" } }; + + cmpl = complement(aut, alph, { {"algorithm", "classical"} }); + + REQUIRE(cmpl.is_in_lang({})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["a"] }, {}})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["b"] }, {}})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["a"], alph["a"]}, {}})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["a"], alph["b"], alph["b"], alph["a"] }, {}})); + + Cntnfa sigma_star_nfa{ cntnfa::builder::create_sigma_star_nfa(&alph) }; + CHECK(are_equivalent(cmpl, sigma_star_nfa)); + } + + SECTION("empty automaton accepting epsilon, empty alphabet") + { + OnTheFlyAlphabet alph{}; + aut.initial = {1}; + aut.final = {1}; + + cmpl = complement(aut, alph, { {"algorithm", "classical"} }); + + CHECK(cmpl.is_lang_empty()); + } + + SECTION("empty automaton accepting epsilon") + { + OnTheFlyAlphabet alph{ std::vector{ "a", "b" } }; + aut.initial = {1}; + aut.final = {1}; + + cmpl = complement(aut, alph, { {"algorithm", "classical"} }); + + REQUIRE(!cmpl.is_in_lang({})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["a"]}, {}})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["b"]}, {}})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["a"], alph["a"]}, {}})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["a"], alph["b"], alph["b"], alph["a"]}, {}})); + REQUIRE(cmpl.initial.size() == 1); + REQUIRE(cmpl.final.size() == 1); + REQUIRE(cmpl.delta.num_of_transitions() == 4); + } + + SECTION("non-empty automaton accepting a*b*") + { + OnTheFlyAlphabet alph{ std::vector{ "a", "b" } }; + aut.initial = {1, 2}; + aut.final = {1, 2}; + + aut.delta.add(1, alph["a"], 1); + aut.delta.add(1, alph["a"], 2); + aut.delta.add(2, alph["b"], 2); + + cmpl = complement(aut, alph, {{"algorithm", "classical"} }); + + REQUIRE(!cmpl.is_in_lang(Word{})); + REQUIRE(!cmpl.is_in_lang(Word{ alph["a"] })); + REQUIRE(!cmpl.is_in_lang(Word{ alph["b"] })); + REQUIRE(!cmpl.is_in_lang(Word{ alph["a"], alph["a"] })); + REQUIRE(cmpl.is_in_lang(Word{ alph["a"], alph["b"], alph["b"], alph["a"] })); + REQUIRE(!cmpl.is_in_lang(Word{ alph["a"], alph["a"], alph["b"], alph["b"] })); + REQUIRE(cmpl.is_in_lang(Word{ alph["b"], alph["a"], alph["a"], alph["a"] })); + + REQUIRE(cmpl.initial.size() == 1); + REQUIRE(cmpl.final.size() == 1); + REQUIRE(cmpl.delta.num_of_transitions() == 6); + } + + SECTION("empty automaton, empty alphabet, minimization") + { + OnTheFlyAlphabet alph{}; + + cmpl = complement(aut, alph, { {"algorithm", "classical"} }); + Cntnfa empty_string_nfa{ cntnfa::builder::create_sigma_star_nfa(&alph) }; + CHECK(are_equivalent(empty_string_nfa, cmpl)); + } + + SECTION("empty automaton, minimization") + { + OnTheFlyAlphabet alph{ std::vector{ "a", "b" } }; + + cmpl = complement(aut, alph, { {"algorithm", "classical"} }); + + REQUIRE(cmpl.is_in_lang({})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["a"] }, {}})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["b"] }, {}})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["a"], alph["a"]}, {}})); + REQUIRE(cmpl.is_in_lang(Run{{ alph["a"], alph["b"], alph["b"], alph["a"] }, {}})); + + Cntnfa sigma_star_nfa{ cntnfa::builder::create_sigma_star_nfa(&alph) }; + CHECK(are_equivalent(sigma_star_nfa, cmpl)); + } + + SECTION("minimization vs no minimization") { + OnTheFlyAlphabet alph{ std::vector{ "a", "b" } }; + aut.initial = {0, 1}; + aut.final = {1, 2}; + + aut.delta.add(1, alph["b"], 1); + aut.delta.add(1, alph["a"], 2); + aut.delta.add(2, alph["b"], 2); + aut.delta.add(0, alph["a"], 1); + aut.delta.add(0, alph["a"], 2); + + cmpl = complement(aut, alph, { {"algorithm", "classical"} }); + Cntnfa cmpl_min = complement(aut, alph, { { "algorithm", "brzozowski"} }); + CHECK(are_equivalent(cmpl, cmpl_min, &alph)); + CHECK(cmpl_min.num_of_states() == 4); + CHECK(cmpl.num_of_states() == 5); + } + +} + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa::is_universal()") +// { +// Cntnfa aut(6); +// Run cex; +// ParameterMap params; + +// const std::unordered_set ALGORITHMS = { +// "naive", +// "antichains", +// }; + +// SECTION("empty automaton, empty alphabet") +// { +// OnTheFlyAlphabet alph{}; + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, params); + +// REQUIRE(!is_univ); +// } +// } + +// SECTION("empty automaton accepting epsilon, empty alphabet") +// { +// OnTheFlyAlphabet alph{}; +// aut.initial = {1}; +// aut.final = {1}; + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, &cex, params); + +// REQUIRE(is_univ); +// REQUIRE(cex.word.empty()); +// } +// } + +// SECTION("empty automaton accepting epsilon") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a" } }; +// aut.initial = {1}; +// aut.final = {1}; + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, &cex, params); + +// REQUIRE(!is_univ); +// REQUIRE(((cex.word == Word{alph["a"]}) || (cex.word == Word{alph["b"]}))); +// } +// } + +// SECTION("automaton for a*b*") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b" } }; +// aut.initial = {1, 2}; +// aut.final = {1, 2}; + +// aut.delta.add(1, alph["a"], 1); +// aut.delta.add(1, alph["a"], 2); +// aut.delta.add(2, alph["b"], 2); + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, params); + +// REQUIRE(!is_univ); +// } +// } + +// SECTION("automaton for a* + b*") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// aut.initial = {1, 2}; +// aut.final = {1, 2}; + +// aut.delta.add(1, alph["a"], 1); +// aut.delta.add(2, alph["b"], 2); + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, params); + +// REQUIRE(!is_univ); +// } +// } + +// SECTION("automaton for (a + b)*") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// aut.initial = {1}; +// aut.final = {1}; + +// aut.delta.add(1, alph["a"], 1); +// aut.delta.add(1, alph["b"], 1); + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, params); + +// REQUIRE(is_univ); +// } +// } + +// SECTION("automaton for eps + (a+b) + (a+b)(a+b)(a* + b*)") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// aut.initial = {1}; +// aut.final = {1, 2, 3, 4, 5}; + +// aut.delta.add(1, alph["a"], 2); +// aut.delta.add(1, alph["b"], 2); +// aut.delta.add(2, alph["a"], 3); +// aut.delta.add(2, alph["b"], 3); + +// aut.delta.add(3, alph["a"], 4); +// aut.delta.add(4, alph["a"], 4); + +// aut.delta.add(3, alph["b"], 5); +// aut.delta.add(5, alph["b"], 5); + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, &cex, params); + +// REQUIRE(!is_univ); + +// REQUIRE(cex.word.size() == 4); +// REQUIRE((cex.word[0] == alph["a"] || cex.word[0] == alph["b"])); +// REQUIRE((cex.word[1] == alph["a"] || cex.word[1] == alph["b"])); +// REQUIRE((cex.word[2] == alph["a"] || cex.word[2] == alph["b"])); +// REQUIRE((cex.word[3] == alph["a"] || cex.word[3] == alph["b"])); +// REQUIRE(cex.word[2] != cex.word[3]); +// } +// } + +// SECTION("automaton for epsilon + a(a + b)* + b(a + b)*") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// aut.initial = {1, 3}; +// aut.final = {1, 2, 4}; + +// aut.delta.add(1, alph["a"], 2); +// aut.delta.add(2, alph["a"], 2); +// aut.delta.add(2, alph["b"], 2); +// aut.delta.add(3, alph["b"], 4); +// aut.delta.add(4, alph["a"], 4); +// aut.delta.add(4, alph["b"], 4); + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, &cex, params); + +// REQUIRE(is_univ); +// } +// } + +// SECTION("example from Abdulla et al. TACAS'10") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// aut.initial = {1, 2}; +// aut.final = {1, 2, 3}; + +// aut.delta.add(1, alph["b"], 1); +// aut.delta.add(1, alph["a"], 2); +// aut.delta.add(1, alph["b"], 4); +// aut.delta.add(2, alph["b"], 2); +// aut.delta.add(2, alph["a"], 3); +// aut.delta.add(3, alph["b"], 3); +// aut.delta.add(3, alph["a"], 1); +// aut.delta.add(4, alph["b"], 2); +// aut.delta.add(4, alph["b"], 3); + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, &cex, params); + +// REQUIRE(is_univ); +// } +// } + +// SECTION("subsumption-pruning in processed") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a" } }; +// aut.initial = {1, 2}; +// aut.final = {1}; + +// aut.delta.add(1, alph["a"], 1); + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_univ = aut.is_universal(alph, &cex, params); + +// REQUIRE(is_univ); +// } +// } + +// SECTION("wrong parameters 1") +// { +// OnTheFlyAlphabet alph{}; + +// CHECK_THROWS_WITH(aut.is_universal(alph, params), +// Catch::Matchers::ContainsSubstring("requires setting the \"algorithm\" key")); +// } + +// SECTION("wrong parameters 2") +// { +// OnTheFlyAlphabet alph{}; +// params["algorithm"] = "foo"; + +// CHECK_THROWS_WITH(aut.is_universal(alph, params), +// Catch::Matchers::ContainsSubstring("received an unknown value")); +// } +// } + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa::is_included()") +// { +// Cntnfa smaller(10); +// Cntnfa bigger(16); +// Run cex; +// ParameterMap params; + +// const std::unordered_set ALGORITHMS = { +// "naive", +// "antichains", +// }; + +// SECTION("{} <= {}, empty alphabet") +// { +// OnTheFlyAlphabet alph{}; + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; +// bool is_incl = is_included(smaller, bigger, &alph, params); +// CHECK(is_incl); + +// is_incl = is_included(bigger, smaller, &alph, params); +// CHECK(is_incl); +// } +// } + +// SECTION("{} <= {epsilon}, empty alphabet") +// { +// OnTheFlyAlphabet alph{}; +// bigger.initial = {1}; +// bigger.final = {1}; + +// for (const auto& algo : ALGORITHMS) { +// SECTION(algo) +// { +// params["algorithm"] = algo; +// bool is_incl = is_included(smaller, bigger, &cex, &alph, params); +// CHECK(is_incl); + +// is_incl = is_included(bigger, smaller, &cex, &alph, params); +// CHECK(!is_incl); +// CHECK(cex.word.empty()); +// REQUIRE(cex.path.size() == 1); +// CHECK(cex.path[0] == 1); +// } +// } +// } + +// SECTION("{epsilon} <= {epsilon}, empty alphabet") +// { +// OnTheFlyAlphabet alph{}; +// smaller.initial = {1}; +// smaller.final = {1}; +// bigger.initial = {11}; +// bigger.final = {11}; + +// for (const auto& algo : ALGORITHMS) { +// SECTION(algo) +// { +// params["algorithm"] = algo; +// bool is_incl = is_included(smaller, bigger, &cex, &alph, params); +// CHECK(is_incl); + +// is_incl = is_included(bigger, smaller, &cex, &alph, params); +// CHECK(is_incl); +// } +// } +// } + +// SECTION("{epsilon} !<= {}, empty alphabet") +// { +// OnTheFlyAlphabet alph{}; +// smaller.initial = {1}; +// smaller.final = {1}; + +// for (const auto& algo : ALGORITHMS) { +// SECTION(algo) +// { +// params["algorithm"] = algo; +// bool is_incl = is_included(smaller, bigger, &cex, &alph, params); + +// REQUIRE(!is_incl); +// REQUIRE(cex.word.empty()); +// REQUIRE(cex.path.size() == 1); +// CHECK(cex.path[0] == 1); + +// is_incl = is_included(bigger, smaller, &cex, &alph, params); +// REQUIRE(cex.word.empty()); +// REQUIRE(is_incl); +// } +// } +// } + +// SECTION("a* + b* <= (a+b)*") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// smaller.initial = {1, 2}; +// smaller.final = {1, 2}; +// smaller.delta.add(1, alph["a"], 1); +// smaller.delta.add(2, alph["b"], 2); + +// bigger.initial = {11}; +// bigger.final = {11}; +// bigger.delta.add(11, alph["a"], 11); +// bigger.delta.add(11, alph["b"], 11); + +// for (const auto& algo : ALGORITHMS) { +// SECTION(algo) +// { +// params["algorithm"] = algo; +// bool is_incl = is_included(smaller, bigger, &alph, params); +// REQUIRE(is_incl); + +// is_incl = is_included(bigger, smaller, &alph, params); +// REQUIRE(!is_incl); +// } +// } +// } + +// SECTION("(a+b)* !<= a* + b*") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// smaller.initial = {1}; +// smaller.final = {1}; +// smaller.delta.add(1, alph["a"], 1); +// smaller.delta.add(1, alph["b"], 1); + +// bigger.initial = {11, 12}; +// bigger.final = {11, 12}; +// bigger.delta.add(11, alph["a"], 11); +// bigger.delta.add(12, alph["b"], 12); + +// for (const auto& algo : ALGORITHMS) { +// SECTION(algo) +// { +// params["algorithm"] = algo; + +// bool is_incl = is_included(smaller, bigger, &cex, &alph, params); + +// REQUIRE(!is_incl); +// REQUIRE(( +// cex.word == Word{alph["a"], alph["b"]} || +// cex.word == Word{alph["b"], alph["a"]})); +// REQUIRE(cex.path == std::vector{1,1,1}); + +// is_incl = is_included(bigger, smaller, &cex, &alph, params); +// REQUIRE(is_incl); +// REQUIRE(( +// cex.word == Word{alph["a"], alph["b"]} || +// cex.word == Word{alph["b"], alph["a"]})); +// REQUIRE(cex.path == std::vector{1,1,1}); +// } +// } +// } + +// SECTION("(a+b)* !<= eps + (a+b) + (a+b)(a+b)(a* + b*)") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// smaller.initial = {1}; +// smaller.final = {1}; +// smaller.delta.add(1, alph["a"], 1); +// smaller.delta.add(1, alph["b"], 1); + +// bigger.initial = {11}; +// bigger.final = {11, 12, 13, 14, 15}; + +// bigger.delta.add(11, alph["a"], 12); +// bigger.delta.add(11, alph["b"], 12); +// bigger.delta.add(12, alph["a"], 13); +// bigger.delta.add(12, alph["b"], 13); + +// bigger.delta.add(13, alph["a"], 14); +// bigger.delta.add(14, alph["a"], 14); + +// bigger.delta.add(13, alph["b"], 15); +// bigger.delta.add(15, alph["b"], 15); + +// for (const auto& algo : ALGORITHMS) { +// SECTION(algo) +// { +// params["algorithm"] = algo; +// bool is_incl = is_included(smaller, bigger, &cex, &alph, params); +// REQUIRE(!is_incl); + +// REQUIRE(cex.word.size() == 4); +// REQUIRE((cex.word[0] == alph["a"] || cex.word[0] == alph["b"])); +// REQUIRE((cex.word[1] == alph["a"] || cex.word[1] == alph["b"])); +// REQUIRE((cex.word[2] == alph["a"] || cex.word[2] == alph["b"])); +// REQUIRE((cex.word[3] == alph["a"] || cex.word[3] == alph["b"])); +// REQUIRE(cex.word[2] != cex.word[3]); +// REQUIRE(cex.path == std::vector{1,1,1,1,1}); + +// is_incl = is_included(bigger, smaller, &cex, &alph, params); +// REQUIRE(is_incl); + +// REQUIRE(cex.word.size() == 4); +// REQUIRE((cex.word[0] == alph["a"] || cex.word[0] == alph["b"])); +// REQUIRE((cex.word[1] == alph["a"] || cex.word[1] == alph["b"])); +// REQUIRE((cex.word[2] == alph["a"] || cex.word[2] == alph["b"])); +// REQUIRE((cex.word[3] == alph["a"] || cex.word[3] == alph["b"])); +// REQUIRE(cex.word[2] != cex.word[3]); +// REQUIRE(cex.path == std::vector{1,1,1,1,1}); +// } +// } +// } + +// SECTION("large example") +// { +// plumbing::construct(&smaller, mata::IntermediateAut::parse_from_mf(parse_mf( +// R"(@NFA-explicit +// %Alphabet-auto +// %Initial q0 +// %Final q10 +// q0 65 q1 +// q0 66 q1 +// q0 67 q1 +// q0 196608 q1 +// q1 65 q2 +// q1 66 q2 +// q1 67 q2 +// q1 196608 q2 +// q2 65 q2 +// q2 65 q3 +// q2 66 q2 +// q2 66 q4 +// q2 67 q2 +// q2 196608 q2 +// q4 66 q5 +// q5 66 q6 +// q6 65 q6 +// q6 65 q7 +// q6 66 q6 +// q6 67 q6 +// q6 196608 q6 +// q7 67 q8 +// q8 67 q9 +// q9 67 q10 +// q10 65 q10 +// q10 66 q10 +// q10 67 q10 +// q10 196608 q10 +// q3 67 q11 +// q11 67 q12 +// q12 67 q13 +// q13 65 q13 +// q13 66 q13 +// q13 66 q14 +// q13 67 q13 +// q13 196608 q13 +// q14 66 q15 +// q15 66 q16 +// q16 65 q10 +// q16 66 q10 +// q16 67 q10 +// q16 196608 q10 +// )" +// ))[0]); +// plumbing::construct(&bigger, mata::IntermediateAut::parse_from_mf(parse_mf( +// R"(@NFA-explicit +// %Alphabet-auto +// %Initial q0 q7 +// %Final q6 +// q0 65 q1 +// q0 66 q1 +// q0 67 q1 +// q0 196608 q1 +// q1 65 q2 +// q1 66 q2 +// q1 67 q2 +// q1 196608 q2 +// q2 65 q2 +// q2 66 q2 +// q2 66 q3 +// q2 67 q2 +// q2 196608 q2 +// q3 66 q4 +// q4 66 q5 +// q5 66 q6 +// q6 65 q6 +// q6 66 q6 +// q6 67 q6 +// q6 196608 q6 +// q7 65 q8 +// q7 66 q8 +// q7 67 q8 +// q7 196608 q8 +// q8 65 q8 +// q8 66 q9 +// q8 67 q8 +// q8 196608 q8 +// q9 65 q9 +// q9 65 q10 +// q9 66 q9 +// q9 67 q9 +// q9 196608 q9 +// q10 67 q5 +// )" +// ))[0]); + +// for (const auto& algo : ALGORITHMS) { +// SECTION(algo) +// { +// params["algorithm"] = algo; +// bool is_incl = is_included(smaller, bigger, &cex, nullptr, params); +// REQUIRE(!is_incl); +// REQUIRE(smaller.is_in_lang(cex.word)); +// REQUIRE(!bigger.is_in_lang(cex.word)); +// REQUIRE(cex.path.size() == cex.word.size() + 1); +// for (size_t i = 0; i < cex.word.size(); ++i) { +// const auto& s = smaller.delta[cex.path[i]].find(cex.word[i]); +// REQUIRE(s != smaller.delta[cex.path[i]].end()); +// CHECK(s->targets.contains(cex.path[i+1])); +// } +// } +// } +// } + +// SECTION("wrong parameters 1") +// { +// OnTheFlyAlphabet alph{}; + +// CHECK_THROWS_WITH(is_included(smaller, bigger, &alph, params), +// Catch::Matchers::ContainsSubstring("requires setting the \"algorithm\" key")); +// CHECK_NOTHROW(is_included(smaller, bigger, &alph)); +// } + +// SECTION("wrong parameters 2") +// { +// OnTheFlyAlphabet alph{}; +// params["algorithm"] = "foo"; + +// CHECK_THROWS_WITH(is_included(smaller, bigger, &alph, params), +// Catch::Matchers::ContainsSubstring("received an unknown value")); +// CHECK_NOTHROW(is_included(smaller, bigger, &alph)); +// } +// } + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa::are_equivalent") +// { +// Cntnfa smaller(10); +// Cntnfa bigger(16); +// Word cex; +// ParameterMap params; + +// const std::unordered_set ALGORITHMS = { +// "naive", +// "antichains", +// }; + +// SECTION("{} == {}, empty alphabet") +// { +// OnTheFlyAlphabet alph{}; + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; + +// CHECK(are_equivalent(smaller, bigger, &alph, params)); +// CHECK(are_equivalent(smaller, bigger, params)); +// CHECK(are_equivalent(smaller, bigger)); + +// CHECK(are_equivalent(bigger, smaller, &alph, params)); +// CHECK(are_equivalent(bigger, smaller, params)); +// CHECK(are_equivalent(bigger, smaller)); +// } +// } + +// SECTION("{} == {epsilon}, empty alphabet") +// { +// OnTheFlyAlphabet alph{}; +// bigger.initial = {1}; +// bigger.final = {1}; + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; + +// CHECK(!are_equivalent(smaller, bigger, &alph, params)); +// CHECK(!are_equivalent(smaller, bigger, params)); +// CHECK(!are_equivalent(smaller, bigger)); + +// CHECK(!are_equivalent(bigger, smaller, &alph, params)); +// CHECK(!are_equivalent(bigger, smaller, params)); +// CHECK(!are_equivalent(bigger, smaller)); +// } +// } + +// SECTION("{epsilon} == {epsilon}, empty alphabet") +// { +// OnTheFlyAlphabet alph{}; +// smaller.initial = {1}; +// smaller.final = {1}; +// bigger.initial = {11}; +// bigger.final = {11}; + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; + +// CHECK(are_equivalent(smaller, bigger, &alph, params)); +// CHECK(are_equivalent(smaller, bigger, params)); +// CHECK(are_equivalent(smaller, bigger)); + +// CHECK(are_equivalent(bigger, smaller, &alph, params)); +// CHECK(are_equivalent(bigger, smaller, params)); +// CHECK(are_equivalent(bigger, smaller)); +// } +// } + +// SECTION("a* + b* == (a+b)*") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// smaller.initial = {1, 2}; +// smaller.final = {1, 2}; +// smaller.delta.add(1, alph["a"], 1); +// smaller.delta.add(2, alph["b"], 2); + +// bigger.initial = {11}; +// bigger.final = {11}; +// bigger.delta.add(11, alph["a"], 11); +// bigger.delta.add(11, alph["b"], 11); + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; + +// // TODO: What about we test the plumbing versions primarily? +// // Debugging with the dispatcher is annoying. + +// CHECK(!are_equivalent(smaller, bigger, &alph, params)); +// CHECK(!are_equivalent(smaller, bigger, params)); +// CHECK(!are_equivalent(smaller, bigger)); + +// CHECK(!are_equivalent(bigger, smaller, &alph, params)); +// CHECK(!are_equivalent(bigger, smaller, params)); +// CHECK(!are_equivalent(bigger, smaller)); +// } +// } + +// /// TODO: Update this test for cntnfa. +// // SECTION("a* != (a|b)*, was throwing exception") +// // { +// // Cntnfa aut; +// // mata::parser::create_nfa(&aut, "a*"); +// // Cntnfa aut2; +// // mata::parser::create_nfa(&aut2, "(a|b)*"); +// // CHECK(!are_equivalent(aut, aut2)); +// // } + +// SECTION("(a+b)* !<= eps + (a+b) + (a+b)(a+b)(a* + b*)") +// { +// OnTheFlyAlphabet alph{ std::vector{ "a", "b"} }; +// smaller.initial = {1}; +// smaller.final = {1}; +// smaller.delta.add(1, alph["a"], 1); +// smaller.delta.add(1, alph["b"], 1); + +// bigger.initial = {11}; +// bigger.final = {11, 12, 13, 14, 15}; + +// bigger.delta.add(11, alph["a"], 12); +// bigger.delta.add(11, alph["b"], 12); +// bigger.delta.add(12, alph["a"], 13); +// bigger.delta.add(12, alph["b"], 13); + +// bigger.delta.add(13, alph["a"], 14); +// bigger.delta.add(14, alph["a"], 14); + +// bigger.delta.add(13, alph["b"], 15); +// bigger.delta.add(15, alph["b"], 15); + +// for (const auto& algo : ALGORITHMS) { +// params["algorithm"] = algo; + +// CHECK(!are_equivalent(smaller, bigger, &alph, params)); +// CHECK(!are_equivalent(smaller, bigger, params)); +// CHECK(!are_equivalent(smaller, bigger)); + +// CHECK(!are_equivalent(bigger, smaller, &alph, params)); +// CHECK(!are_equivalent(bigger, smaller, params)); +// CHECK(!are_equivalent(bigger, smaller)); +// } +// } + +// SECTION("wrong parameters 1") +// { +// OnTheFlyAlphabet alph{}; + +// CHECK_THROWS_WITH(are_equivalent(smaller, bigger, &alph, params), +// Catch::Matchers::ContainsSubstring("requires setting the \"algorithm\" key")); +// CHECK_THROWS_WITH(are_equivalent(smaller, bigger, params), +// Catch::Matchers::ContainsSubstring("requires setting the \"algorithm\" key")); +// CHECK_NOTHROW(are_equivalent(smaller, bigger)); +// } + +// SECTION("wrong parameters 2") +// { +// OnTheFlyAlphabet alph{}; +// params["algorithm"] = "foo"; + +// CHECK_THROWS_WITH(are_equivalent(smaller, bigger, &alph, params), +// Catch::Matchers::ContainsSubstring("received an unknown value")); +// CHECK_THROWS_WITH(are_equivalent(smaller, bigger, params), +// Catch::Matchers::ContainsSubstring("received an unknown value")); +// CHECK_NOTHROW(are_equivalent(smaller, bigger)); +// } +// } + +TEST_CASE("mata::cntnfa::revert()") +{ // {{{ + Cntnfa aut(9); + + SECTION("empty automaton") + { + Cntnfa result = revert(aut); + + REQUIRE(result.delta.empty()); + REQUIRE(result.initial.empty()); + REQUIRE(result.final.empty()); + } + + SECTION("no-transition automaton") + { + aut.initial.insert(1); + aut.initial.insert(3); + + aut.final.insert(2); + aut.final.insert(5); + + Cntnfa result = revert(aut); + + REQUIRE(result.delta.empty()); + REQUIRE(result.initial[2]); + REQUIRE(result.initial[5]); + REQUIRE(result.final[1]); + REQUIRE(result.final[3]); + } + + SECTION("one-transition automaton") + { + aut.initial.insert(1); + aut.final.insert(2); + aut.delta.add(1, 'a', 2); + + Cntnfa result = revert(aut); + + REQUIRE(result.initial[2]); + REQUIRE(result.final[1]); + REQUIRE(result.delta.contains(2, 'a', 1)); + REQUIRE(result.delta.num_of_transitions() == aut.delta.num_of_transitions()); + } + + SECTION("bigger automaton") + { + aut.initial = {1, 2}; + aut.delta.add(1, 'a', 2); + aut.delta.add(1, 'a', 3); + aut.delta.add(1, 'b', 4); + aut.delta.add(2, 'a', 2); + aut.delta.add(2, 'a', 3); + aut.delta.add(2, 'b', 4); + aut.delta.add(3, 'b', 4); + aut.delta.add(3, 'c', 7); + aut.delta.add(3, 'b', 2); + aut.delta.add(7, 'a', 8); + aut.final = {3}; + + Cntnfa result = revert(aut); + //REQUIRE(result.final == StateSet({1, 2})); + REQUIRE(StateSet(result.final) == StateSet({1, 2})); + REQUIRE(result.delta.contains(2, 'a', 1)); + REQUIRE(result.delta.contains(3, 'a', 1)); + REQUIRE(result.delta.contains(4, 'b', 1)); + REQUIRE(result.delta.contains(2, 'a', 2)); + REQUIRE(result.delta.contains(3, 'a', 2)); + REQUIRE(result.delta.contains(4, 'b', 2)); + REQUIRE(result.delta.contains(4, 'b', 3)); + REQUIRE(result.delta.contains(7, 'c', 3)); + REQUIRE(result.delta.contains(2, 'b', 3)); + REQUIRE(result.delta.contains(8, 'a', 7)); + REQUIRE(StateSet(result.initial) == StateSet({3})); + } + + SECTION("Automaton A") { + Cntnfa nfa{ 11 }; + FILL_WITH_AUT_A(nfa); + Cntnfa res = revert(nfa); + CHECK(res.initial[5]); + CHECK(res.final[1]); + CHECK(res.final[3]); + CHECK(res.delta.num_of_transitions() == 15); + CHECK(res.delta.contains(5, 'a', 5)); + CHECK(res.delta.contains(5, 'a', 7)); + CHECK(res.delta.contains(9, 'a', 9)); + CHECK(res.delta.contains(9, 'c', 5)); + CHECK(res.delta.contains(9, 'b', 3)); + CHECK(res.delta.contains(7, 'a', 3)); + CHECK(res.delta.contains(7, 'a', 10)); + CHECK(res.delta.contains(7, 'b', 10)); + CHECK(res.delta.contains(7, 'c', 10)); + CHECK(res.delta.contains(7, 'b', 1)); + CHECK(res.delta.contains(3, 'a', 7)); + CHECK(res.delta.contains(3, 'c', 7)); + CHECK(res.delta.contains(3, 'a', 1)); + CHECK(res.delta.contains(1, 'b', 7)); + CHECK(res.delta.contains(10, 'a', 1)); + } + + SECTION("Automaton B") { + Cntnfa nfa{ 15 }; + FILL_WITH_AUT_B(nfa); + Cntnfa res = revert(nfa); + CHECK(res.initial[2]); + CHECK(res.initial[12]); + CHECK(res.final[4]); + CHECK(res.delta.num_of_transitions() == 12); + CHECK(res.delta.contains(8, 'a', 4)); + CHECK(res.delta.contains(8, 'c', 4)); + CHECK(res.delta.contains(4, 'b', 8)); + CHECK(res.delta.contains(6, 'b', 4)); + CHECK(res.delta.contains(6, 'a', 4)); + CHECK(res.delta.contains(2, 'a', 6)); + CHECK(res.delta.contains(2, 'a', 0)); + CHECK(res.delta.contains(2, 'b', 2)); + CHECK(res.delta.contains(0, 'a', 2)); + CHECK(res.delta.contains(12, 'c', 2)); + CHECK(res.delta.contains(12, 'b', 14)); + CHECK(res.delta.contains(14, 'a', 12)); + } +} // }}} + + +TEST_CASE("mata::cntnfa::Cntnfa::is_deterministic()") +{ // {{{ + Cntnfa aut('s'+1); + + SECTION("(almost) empty automaton") { + // no initial states + REQUIRE(!aut.is_deterministic()); + + // add an initial state + aut.initial.insert('q'); + REQUIRE(aut.is_deterministic()); + + // add the same initial state + aut.initial.insert('q'); + REQUIRE(aut.is_deterministic()); + + // add another initial state + aut.initial.insert('r'); + REQUIRE(!aut.is_deterministic()); + + // add a final state + aut.final.insert('q'); + REQUIRE(!aut.is_deterministic()); + } + + SECTION("trivial automata") { + aut.initial.insert('q'); + aut.delta.add('q', 'a', 'r'); + REQUIRE(aut.is_deterministic()); + + // unreachable states + aut.delta.add('s', 'a', 'r'); + REQUIRE(aut.is_deterministic()); + + // transitions over a different symbol + aut.delta.add('q', 'b', 'h'); + REQUIRE(aut.is_deterministic()); + + // nondeterminism + aut.delta.add('q', 'a', 's'); + REQUIRE(!aut.is_deterministic()); + } + + SECTION("larger automaton 1") { + FILL_WITH_AUT_A(aut); + REQUIRE(!aut.is_deterministic()); + } + + SECTION("larger automaton 2") { + FILL_WITH_AUT_B(aut); + REQUIRE(!aut.is_deterministic()); + } +} // }}} + +TEST_CASE("mata::cntnfa::is_complete()") +{ // {{{ + Cntnfa aut('q'+1); + + SECTION("empty automaton") + { + OnTheFlyAlphabet alph{}; + + // is complete for the empty alphabet + REQUIRE(aut.is_complete(&alph)); + + alph.translate_symb("a1"); + alph.translate_symb("a2"); + + // the empty automaton is complete even for a non-empty alphabet + REQUIRE(aut.is_complete(&alph)); + + // add a non-reachable state (the automaton should still be complete) + aut.delta.add('q', alph["a1"], 'q'); + REQUIRE(aut.is_complete(&alph)); + } + + SECTION("small automaton") + { + OnTheFlyAlphabet alph{}; + + aut.initial.insert(4); + aut.delta.add(4, alph["a"], 8); + aut.delta.add(4, alph["c"], 8); + aut.delta.add(4, alph["a"], 6); + aut.delta.add(4, alph["b"], 6); + aut.delta.add(8, alph["b"], 4); + aut.delta.add(6, alph["a"], 2); + aut.delta.add(2, alph["b"], 2); + aut.delta.add(2, alph["a"], 0); + aut.delta.add(2, alph["c"], 12); + aut.delta.add(0, alph["a"], 2); + aut.delta.add(12, alph["a"], 14); + aut.delta.add(14, alph["b"], 12); + aut.final.insert({2, 12}); + + REQUIRE(!aut.is_complete(&alph)); + + aut.make_complete(&alph, 100); + REQUIRE(aut.is_complete(&alph)); + } + + SECTION("using a non-alphabet symbol") + { + OnTheFlyAlphabet alph{}; + + aut.initial.insert(4); + aut.delta.add(4, alph["a"], 8); + aut.delta.add(4, alph["c"], 8); + aut.delta.add(4, alph["a"], 6); + aut.delta.add(4, alph["b"], 6); + aut.delta.add(6, 100, 4); + + CHECK_THROWS_WITH(aut.is_complete(&alph), + Catch::Matchers::ContainsSubstring("symbol that is not in the provided alphabet")); + } +} // }}} + +TEST_CASE("mata::cntnfa::is_prfx_in_lang()") +{ // {{{ + Cntnfa aut('q'+1); + + SECTION("empty automaton") + { + Run w; + w.word = {'a', 'b', 'd'}; + REQUIRE(!aut.is_prfx_in_lang(w)); + + w.word = { }; + REQUIRE(!aut.is_prfx_in_lang(w)); + } + + SECTION("automaton accepting only epsilon") + { + aut.initial.insert('q'); + aut.final.insert('q'); + + Run w; + w.word = { }; + REQUIRE(aut.is_prfx_in_lang(w)); + + w.word = {'a', 'b'}; + REQUIRE(aut.is_prfx_in_lang(w)); + } + + SECTION("small automaton") + { + FILL_WITH_AUT_B(aut); + + Run w; + w.word = {'b', 'a'}; + REQUIRE(aut.is_prfx_in_lang(w)); + + w.word = { }; + REQUIRE(!aut.is_prfx_in_lang(w)); + + w.word = {'c', 'b', 'a'}; + REQUIRE(!aut.is_prfx_in_lang(w)); + + w.word = {'c', 'b', 'a', 'a'}; + REQUIRE(aut.is_prfx_in_lang(w)); + + w.word = {'a', 'a'}; + REQUIRE(aut.is_prfx_in_lang(w)); + + w.word = {'c', 'b', 'b', 'a', 'c', 'b'}; + REQUIRE(aut.is_prfx_in_lang(w)); + + w.word = Word(100000, 'a'); + REQUIRE(aut.is_prfx_in_lang(w)); + + w.word = Word(100000, 'b'); + REQUIRE(!aut.is_prfx_in_lang(w)); + } +} // }}} + +TEST_CASE("mata::cntnfa::fw-direct-simulation()") +{ // {{{ + Cntnfa aut; + + SECTION("empty automaton") + { + Simlib::Util::BinaryRelation result = compute_relation(aut); + + REQUIRE(result.size() == 0); + } + + aut.add_state(8); + SECTION("no-transition automaton") + { + aut.initial.insert(1); + aut.initial.insert(3); + + aut.final.insert(2); + aut.final.insert(5); + + Simlib::Util::BinaryRelation result = compute_relation(aut); + REQUIRE(result.get(1,3)); + REQUIRE(result.get(2,5)); + REQUIRE(!result.get(5,1)); + REQUIRE(!result.get(2,3)); + } + + SECTION("small automaton") + { + aut.initial.insert(1); + aut.final.insert(2); + aut.delta.add(1, 'a', 4); + aut.delta.add(4, 'b', 5); + aut.delta.add(2, 'b', 5); + aut.delta.add(1, 'b', 4); + + Simlib::Util::BinaryRelation result = compute_relation(aut); + REQUIRE(result.get(4,1)); + REQUIRE(!result.get(2,5)); + + } + + Cntnfa aut_big(9); + + SECTION("bigger automaton") + { + aut_big.initial = {1, 2}; + aut_big.delta.add(1, 'a', 2); + aut_big.delta.add(1, 'a', 3); + aut_big.delta.add(1, 'b', 4); + aut_big.delta.add(2, 'a', 2); + aut_big.delta.add(2, 'b', 2); + aut_big.delta.add(2, 'a', 3); + aut_big.delta.add(2, 'b', 4); + aut_big.delta.add(3, 'b', 4); + aut_big.delta.add(3, 'c', 7); + aut_big.delta.add(3, 'b', 2); + aut_big.delta.add(5, 'c', 3); + aut_big.delta.add(7, 'a', 8); + aut_big.final = {3}; + + Simlib::Util::BinaryRelation result = compute_relation(aut_big); + REQUIRE(result.get(1,2)); + REQUIRE(!result.get(2,1)); + REQUIRE(!result.get(3,1)); + REQUIRE(!result.get(3,2)); + REQUIRE(result.get(4,1)); + REQUIRE(result.get(4,2)); + REQUIRE(result.get(4,5)); + REQUIRE(!result.get(5,2)); + REQUIRE(!result.get(5,1)); + REQUIRE(result.get(7,1)); + REQUIRE(result.get(7,2)); + REQUIRE(result.get(8,1)); + REQUIRE(result.get(8,2)); + REQUIRE(result.get(8,5)); + } +} // }} + +TEST_CASE("mata::cntnfa::reduce_size_by_simulation()") +{ + Cntnfa aut; + StateRenaming state_renaming; + + SECTION("empty automaton") + { + Cntnfa result = reduce(aut, &state_renaming); + + REQUIRE(result.delta.empty()); + REQUIRE(result.initial.empty()); + REQUIRE(result.final.empty()); + } + + SECTION("simple automaton") + { + aut.add_state(2); + aut.initial.insert(1); + + aut.final.insert(2); + Cntnfa result = reduce(aut, &state_renaming); + + REQUIRE(result.delta.empty()); + REQUIRE(result.initial[state_renaming[1]]); + REQUIRE(result.final[state_renaming[2]]); + REQUIRE(result.num_of_states() == 2); + REQUIRE(state_renaming[1] == state_renaming[0]); + REQUIRE(state_renaming[2] != state_renaming[0]); + } + + SECTION("big automaton") + { + aut.add_state(9); + aut.initial = {1, 2}; + aut.delta.add(1, 'a', 2); + aut.delta.add(1, 'a', 3); + aut.delta.add(1, 'b', 4); + aut.delta.add(2, 'a', 2); + aut.delta.add(2, 'b', 2); + aut.delta.add(2, 'a', 3); + aut.delta.add(2, 'b', 4); + aut.delta.add(3, 'b', 4); + aut.delta.add(3, 'c', 7); + aut.delta.add(3, 'b', 2); + aut.delta.add(5, 'c', 3); + aut.delta.add(7, 'a', 8); + aut.delta.add(9, 'b', 2); + aut.delta.add(9, 'c', 0); + aut.delta.add(0, 'a', 4); + aut.final = {3, 9}; + + + Cntnfa result = reduce(aut, &state_renaming); + + REQUIRE(result.num_of_states() == 6); + REQUIRE(result.initial[state_renaming[1]]); + REQUIRE(result.initial[state_renaming[2]]); + REQUIRE(result.delta.contains(state_renaming[9], 'c', state_renaming[0])); + REQUIRE(result.delta.contains(state_renaming[9], 'c', state_renaming[7])); + REQUIRE(result.delta.contains(state_renaming[3], 'c', state_renaming[0])); + REQUIRE(result.delta.contains(state_renaming[0], 'a', state_renaming[8])); + REQUIRE(result.delta.contains(state_renaming[7], 'a', state_renaming[4])); + REQUIRE(result.delta.contains(state_renaming[1], 'a', state_renaming[3])); + REQUIRE(!result.delta.contains(state_renaming[3], 'b', state_renaming[4])); + REQUIRE(result.delta.contains(state_renaming[2], 'a', state_renaming[2])); + REQUIRE(result.final[state_renaming[9]]); + REQUIRE(result.final[state_renaming[3]]); + + result = reduce(aut.trim(), &state_renaming); + CHECK(result.num_of_states() == 3); + CHECK(result.initial == SparseSet{ 0, 1 }); + CHECK(result.final == SparseSet{ 2 }); + CHECK(result.delta.num_of_transitions() == 6); + CHECK(result.delta.contains(state_renaming[0], 'a', state_renaming[2])); + CHECK(result.delta.contains(state_renaming[0], 'a', state_renaming[1])); + CHECK(result.delta.contains(state_renaming[1], 'a', state_renaming[1])); + CHECK(result.delta.contains(state_renaming[1], 'b', state_renaming[1])); + CHECK(result.delta.contains(state_renaming[1], 'a', state_renaming[2])); + CHECK(result.delta.contains(state_renaming[2], 'b', state_renaming[1])); + } + + SECTION("no transitions from non-final state") + { + aut.delta.add(0, 'a', 1); + aut.initial = { 0 }; + Cntnfa result = reduce(aut.trim(), &state_renaming); + CHECK(are_equivalent(result, aut)); + } +} + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa::algorithms::minimize_hopcroft()") { +// SECTION("empty automaton") { +// Cntnfa aut; +// Cntnfa result = minimize_hopcroft(aut); +// CHECK(result.is_lang_empty()); +// } + +// SECTION("one state") { +// Cntnfa aut(1); +// aut.initial.insert(0); +// aut.final.insert(0); +// Cntnfa result = minimize_hopcroft(aut); +// CHECK(result.delta.num_of_transitions() == 0); +// CHECK(result.num_of_states() == 1); +// CHECK(result.initial.size() == 1); +// CHECK(result.final.size() == 1); +// CHECK(result.initial == result.final); +// } + +// SECTION("one trans") { +// Cntnfa aut(2); +// aut.initial.insert(0); +// aut.final.insert(1); +// aut.delta.add(0, 'a', 1); +// Cntnfa result = minimize_hopcroft(aut); +// CHECK(result.delta.num_of_transitions() == 1); +// CHECK(result.num_of_states() == 2); +// CHECK(result.initial.size() == 1); +// CHECK(result.final.size() == 1); +// CHECK(result.initial != result.final); +// CHECK(are_equivalent(aut, result)); +// } + +// SECTION("line") { +// Cntnfa aut(3); +// aut.initial.insert(0); +// aut.final.insert(2); +// aut.delta.add(0, 'a', 1); +// aut.delta.add(1, 'a', 2); +// aut.delta.add(2, 'a', 3); +// Cntnfa result = minimize_hopcroft(aut); +// CHECK(result.delta.num_of_transitions() == 3); +// CHECK(result.num_of_states() == 4); +// CHECK(result.initial.size() == 1); +// CHECK(result.final.size() == 1); +// CHECK(result.initial != result.final); +// CHECK(are_equivalent(aut, result)); +// } + +// SECTION("loop") { +// Cntnfa aut; +// aut.initial.insert(0); +// aut.final.insert(1); +// aut.delta.add(0, 1, 2); +// aut.delta.add(1, 0, 1); +// aut.delta.add(1, 1, 1); +// aut.delta.add(2, 1, 1); + +// Cntnfa aut_brz = minimize_brzozowski(aut); +// Cntnfa aut_hop = minimize_hopcroft(aut); +// CHECK(are_equivalent(aut_brz, aut_hop)); +// CHECK(aut_brz.num_of_states() == aut_hop.num_of_states()); +// CHECK(aut_brz.delta.num_of_transitions() == aut_hop.delta.num_of_transitions()); +// CHECK(aut_brz.initial.size() == aut_hop.initial.size()); +// CHECK(aut_brz.final.size() == aut_hop.final.size()); +// } + +// SECTION("difficult") { +// Cntnfa aut; +// aut.initial.insert(0); +// aut.final.insert(1); +// aut.final.insert(6); +// aut.delta.add(0, 0, 1); +// aut.delta.add(1, 0, 2); +// aut.delta.add(2, 0, 4); +// aut.delta.add(4, 1, 5); +// aut.delta.add(4, 0, 3); +// aut.delta.add(5, 0, 6); +// aut.delta.add(3, 0, 1); + +// Cntnfa aut_brz = minimize_brzozowski(aut); +// Cntnfa aut_hop = minimize_hopcroft(aut); +// CHECK(are_equivalent(aut_brz, aut_hop)); +// CHECK(aut_brz.num_of_states() == aut_hop.num_of_states()); +// CHECK(aut_brz.delta.num_of_transitions() == aut_hop.delta.num_of_transitions()); +// CHECK(aut_brz.initial.size() == aut_hop.initial.size()); +// CHECK(aut_brz.final.size() == aut_hop.final.size()); +// } +// } + +TEST_CASE("mata::cntnfa::reduce_size_by_residual()") { + Cntnfa aut; + StateRenaming state_renaming; + ParameterMap params_after, params_with; + params_after["algorithm"] = "residual"; + params_with["algorithm"] = "residual"; + + SECTION("empty automaton") + { + params_after["type"] = "after"; + params_after["direction"] = "forward"; + params_with["type"] = "with"; + params_with["direction"] = "forward"; + + Cntnfa result_after = reduce(aut, &state_renaming, params_after); + Cntnfa result_with = reduce(aut, &state_renaming, params_with); + + REQUIRE(result_after.delta.empty()); + REQUIRE(result_after.initial.empty()); + REQUIRE(result_after.final.empty()); + REQUIRE(result_after.is_identical(result_with)); + REQUIRE(are_equivalent(aut, result_after)); + } + + SECTION("simple automaton") + { + params_after["type"] = "after"; + params_after["direction"] = "forward"; + params_with["type"] = "with"; + params_with["direction"] = "forward"; + aut.add_state(2); + aut.initial.insert(1); + + aut.final.insert(2); + Cntnfa result_after = reduce(aut, &state_renaming, params_after); + Cntnfa result_with = reduce(aut, &state_renaming, params_with); + + REQUIRE(result_after.num_of_states() == 0); + REQUIRE(result_after.initial.empty()); + REQUIRE(result_after.final.empty()); + REQUIRE(result_after.delta.empty()); + REQUIRE(result_after.is_identical(result_with)); + REQUIRE(are_equivalent(aut, result_after)); + + aut.delta.add(1, 'a', 2); + result_after = reduce(aut, &state_renaming, params_after); + result_with = reduce(aut, &state_renaming, params_with); + + REQUIRE(result_after.num_of_states() == 2); + REQUIRE(result_after.initial[0]); + REQUIRE(result_after.final[1]); + REQUIRE(result_after.delta.contains(0, 'a', 1)); + REQUIRE(result_after.is_identical(result_with)); + REQUIRE(are_equivalent(aut, result_after)); + } + + SECTION("medium automaton") + { + params_after["type"] = "after"; + params_after["direction"] = "forward"; + params_with["type"] = "with"; + params_with["direction"] = "forward"; + aut.add_state(4); + + aut.initial = { 1 }; + aut.final = { 2,3 }; + aut.delta.add(1, 'b', 4); + aut.delta.add(1, 'a', 3); + aut.delta.add(4, 'a', 2); + aut.delta.add(4, 'a', 3); + aut.delta.add(3, 'a', 2); + aut.delta.add(3, 'a', 3); + aut.delta.add(2, 'a', 1); + + Cntnfa result_after = reduce(aut, &state_renaming, params_after); + Cntnfa result_with = reduce(aut, &state_renaming, params_with); + + REQUIRE(result_after.num_of_states() == 4); + REQUIRE(result_after.initial[0]); + REQUIRE(result_after.delta.contains(0, 'a', 1)); + REQUIRE(result_after.delta.contains(0, 'b', 2)); + REQUIRE(result_after.delta.contains(1, 'a', 3)); + REQUIRE(!result_after.delta.contains(1, 'b', 3)); + REQUIRE(result_after.delta.contains(2, 'a', 3)); + REQUIRE(!result_after.delta.contains(2, 'a', 2)); + REQUIRE(result_after.delta.contains(3, 'a', 3)); + REQUIRE(result_after.delta.contains(3, 'a', 0)); + REQUIRE(!result_after.delta.contains(3, 'b', 2)); + REQUIRE(result_after.final[1]); + REQUIRE(result_after.final[3]); + REQUIRE(result_after.is_identical(result_with)); + } + + SECTION("big automaton") + { + params_after["type"] = "after"; + params_after["direction"] = "forward"; + params_with["type"] = "with"; + params_with["direction"] = "forward"; + aut.add_state(7); + + aut.initial = { 0 }; + aut.final = { 0,1,2,4,5,6 }; + aut.delta.add(0, 'a', 1); + aut.delta.add(0, 'b', 1); + aut.delta.add(0, 'c', 1); + aut.delta.add(0, 'd', 2); + + aut.delta.add(1, 'a', 1); + aut.delta.add(1, 'b', 1); + aut.delta.add(1, 'c', 1); + aut.delta.add(1, 'd', 1); + + aut.delta.add(2, 'a', 3); + aut.delta.add(2, 'b', 1); + aut.delta.add(2, 'c', 4); + aut.delta.add(2, 'd', 1); + + aut.delta.add(3, 'a', 1); + aut.delta.add(3, 'b', 1); + aut.delta.add(3, 'c', 1); + aut.delta.add(3, 'd', 1); + + aut.delta.add(4, 'a', 1); + aut.delta.add(4, 'b', 1); + aut.delta.add(4, 'c', 1); + aut.delta.add(4, 'd', 5); + + aut.delta.add(5, 'a', 3); + aut.delta.add(5, 'b', 1); + aut.delta.add(5, 'c', 1); + aut.delta.add(5, 'd', 6); + + aut.delta.add(6, 'a', 3); + aut.delta.add(6, 'b', 1); + aut.delta.add(6, 'c', 1); + aut.delta.add(6, 'd', 1); + + Cntnfa result_after = reduce(aut, &state_renaming, params_after); + Cntnfa result_with = reduce(aut, &state_renaming, params_with); + + REQUIRE(result_after.num_of_states() == 5); + REQUIRE(result_after.initial[0]); + REQUIRE(result_after.delta.contains(0, 'd', 1)); + REQUIRE(!result_after.delta.contains(0, 'd', 0)); + REQUIRE(!result_after.delta.contains(0, 'd', 2)); + REQUIRE(result_after.delta.contains(0, 'a', 0)); + REQUIRE(result_after.delta.contains(0, 'a', 1)); + REQUIRE(result_after.delta.contains(0, 'b', 0)); + REQUIRE(result_after.delta.contains(0, 'b', 1)); + REQUIRE(result_after.delta.contains(0, 'c', 0)); + REQUIRE(result_after.delta.contains(0, 'c', 1)); + + REQUIRE(result_after.delta.contains(1, 'a', 2)); + REQUIRE(!result_after.delta.contains(1, 'a', 3)); + REQUIRE(result_after.delta.contains(1, 'b', 0)); + REQUIRE(result_after.delta.contains(1, 'b', 1)); + REQUIRE(result_after.delta.contains(1, 'c', 3)); + REQUIRE(!result_after.delta.contains(1, 'c', 2)); + REQUIRE(result_after.delta.contains(1, 'd', 0)); + REQUIRE(result_after.delta.contains(1, 'd', 1)); + + REQUIRE(result_after.delta.contains(2, 'a', 0)); + REQUIRE(result_after.delta.contains(2, 'a', 1)); + REQUIRE(result_after.delta.contains(2, 'b', 0)); + REQUIRE(result_after.delta.contains(2, 'b', 1)); + REQUIRE(result_after.delta.contains(2, 'c', 0)); + REQUIRE(result_after.delta.contains(2, 'c', 1)); + REQUIRE(result_after.delta.contains(2, 'd', 0)); + REQUIRE(result_after.delta.contains(2, 'd', 1)); + + REQUIRE(result_after.delta.contains(3, 'a', 0)); + REQUIRE(result_after.delta.contains(3, 'a', 1)); + REQUIRE(result_after.delta.contains(3, 'b', 0)); + REQUIRE(result_after.delta.contains(3, 'b', 1)); + REQUIRE(result_after.delta.contains(3, 'c', 0)); + REQUIRE(result_after.delta.contains(3, 'c', 1)); + REQUIRE(result_after.delta.contains(3, 'd', 4)); + REQUIRE(!result_after.delta.contains(3, 'd', 2)); + REQUIRE(!result_after.delta.contains(3, 'd', 3)); + + REQUIRE(result_after.delta.contains(4, 'a', 2)); + REQUIRE(result_after.delta.contains(4, 'b', 0)); + REQUIRE(result_after.delta.contains(4, 'b', 1)); + REQUIRE(result_after.delta.contains(4, 'c', 0)); + REQUIRE(result_after.delta.contains(4, 'c', 1)); + REQUIRE(result_after.delta.contains(4, 'd', 1)); + REQUIRE(result_after.delta.contains(4, 'd', 4)); + REQUIRE(!result_after.delta.contains(4, 'd', 0)); + REQUIRE(!result_after.delta.contains(4, 'd', 3)); + REQUIRE(result_after.final[0]); + REQUIRE(result_after.final[1]); + REQUIRE(result_after.final[3]); + REQUIRE(result_after.final[4]); + REQUIRE(are_equivalent(result_after, result_with)); + REQUIRE(are_equivalent(aut, result_after)); + } + + SECTION("backward residual big automaton") + { + params_after["type"] = "after"; + params_after["direction"] = "backward"; + params_with["type"] = "with"; + params_with["direction"] = "backward"; + + aut.add_state(7); + + aut.initial = { 0 }; + aut.final = { 0,1,2,4,5,6 }; + aut.delta.add(0, 'a', 1); + aut.delta.add(0, 'b', 1); + aut.delta.add(0, 'c', 1); + aut.delta.add(0, 'd', 2); + + aut.delta.add(1, 'a', 1); + aut.delta.add(1, 'b', 1); + aut.delta.add(1, 'c', 1); + aut.delta.add(1, 'd', 1); + + aut.delta.add(2, 'a', 3); + aut.delta.add(2, 'b', 1); + aut.delta.add(2, 'c', 4); + aut.delta.add(2, 'd', 1); + + aut.delta.add(3, 'a', 1); + aut.delta.add(3, 'b', 1); + aut.delta.add(3, 'c', 1); + aut.delta.add(3, 'd', 1); + + aut.delta.add(4, 'a', 1); + aut.delta.add(4, 'b', 1); + aut.delta.add(4, 'c', 1); + aut.delta.add(4, 'd', 5); + + aut.delta.add(5, 'a', 3); + aut.delta.add(5, 'b', 1); + aut.delta.add(5, 'c', 1); + aut.delta.add(5, 'd', 6); + + aut.delta.add(6, 'a', 3); + aut.delta.add(6, 'b', 1); + aut.delta.add(6, 'c', 1); + aut.delta.add(6, 'd', 1); + + Cntnfa result_after = reduce(aut, &state_renaming, params_after); + Cntnfa result_with = reduce(aut, &state_renaming, params_with); + + REQUIRE(result_after.num_of_states() == 6); + REQUIRE(result_after.initial[0]); + REQUIRE(result_after.initial[1]); + REQUIRE(result_after.initial[3]); + REQUIRE(result_after.initial[4]); + + REQUIRE(!result_after.delta.contains(0, 'a', 0)); + REQUIRE(!result_after.delta.contains(0, 'c', 2)); + + REQUIRE(result_after.delta.contains(1, 'a', 0)); + REQUIRE(!result_after.delta.contains(1, 'd', 2)); + REQUIRE(!result_after.delta.contains(1, 'd', 3)); + + REQUIRE(result_after.delta.contains(2, 'd', 1)); + REQUIRE(!result_after.delta.contains(2, 'c', 4)); + + REQUIRE(result_after.delta.contains(3, 'c', 2)); + REQUIRE(result_after.delta.contains(3, 'c', 4)); + + REQUIRE(result_after.delta.contains(4, 'd', 2)); + REQUIRE(!result_after.delta.contains(4, 'd', 3)); + + REQUIRE(result_after.delta.contains(5, 'd', 3)); + + REQUIRE(result_after.final[0]); + + REQUIRE(are_equivalent(result_after, result_with)); + REQUIRE(are_equivalent(aut, result_after)); + + } + + SECTION("error checking") + { + CHECK_THROWS_WITH(reduce(aut, &state_renaming, params_after), + Catch::Matchers::ContainsSubstring("requires setting the \"type\" key in the \"params\" argument;")); + + params_after["type"] = "bad_type"; + CHECK_THROWS_WITH(reduce(aut, &state_renaming, params_after), + Catch::Matchers::ContainsSubstring("requires setting the \"direction\" key in the \"params\" argument;")); + + params_after["direction"] = "unknown_direction"; + CHECK_THROWS_WITH(reduce(aut, &state_renaming, params_after), + Catch::Matchers::ContainsSubstring("received an unknown value of the \"direction\" key")); + + params_after["direction"] = "forward"; + CHECK_THROWS_WITH(reduce(aut, &state_renaming, params_after), + Catch::Matchers::ContainsSubstring("received an unknown value of the \"type\" key")); + + params_after["type"] = "after"; + CHECK_NOTHROW(reduce(aut, &state_renaming, params_after)); + + } +} + +TEST_CASE("mata::cntnfa::union_nondet_counter_nfas()") { + // Define runs for testing + Run zero{{0}, {}}; + Run one{{1}, {}}; + + // First automaton + Cntnfa lhs(2); + size_t c0_id_lhs = lhs.counter_set.add("c0"); + size_t ann_set_lhs = lhs.annotation_collection.insert(std::make_shared(c0_id_lhs, 1)); + + lhs.initial.insert(0); + lhs.delta.add(0, 0, AnnotationState(1, ann_set_lhs)); + lhs.final.insert(1); + + REQUIRE(lhs.is_in_lang_of_counter_nfa(zero)); + REQUIRE_FALSE(lhs.is_in_lang_of_counter_nfa(one)); + + // Second automaton + Cntnfa rhs(2); + size_t c1_id_rhs = rhs.counter_set.add("c1"); + size_t ann_set_rhs = rhs.annotation_collection.insert(std::make_shared(c1_id_rhs, 2)); + + rhs.initial.insert(0); + rhs.delta.add(0, 1, AnnotationState(1, ann_set_rhs)); + rhs.final.insert(1); + + REQUIRE(rhs.is_in_lang_of_counter_nfa(one)); + REQUIRE_FALSE(rhs.is_in_lang_of_counter_nfa(zero)); + + SECTION("Union accepts both languages") { + Cntnfa result = union_nondet_counter_nfas(lhs, rhs); + CHECK(result.is_in_lang_of_counter_nfa(zero)); + CHECK(result.is_in_lang_of_counter_nfa(one)); + } +} + +TEST_CASE("mata::cntnfa::intersection_counter_nfas() - simple intersection") +{ + // First automaton A + Cntnfa a; + a.initial.insert(0); + a.final.insert(2); + a.delta.add(0, 'a', 1); + a.delta.add(1, 'b', 2); + + // Add a counter and an annotation to A + size_t c_a = a.counter_set.add("c0", 0); + size_t ann_id_a = a.annotation_collection.insert(std::make_shared(c_a, 1)); + a.delta.add(2, 'c', AnnotationState(2, ann_id_a)); + + // Second automaton B + Cntnfa b; + b.initial.insert(0); + b.final.insert(2); + b.delta.add(0, 'a', 1); + b.delta.add(1, 'b', 2); + + // Add a counter and an annotation to B + size_t c_b = b.counter_set.add("c1", 0); + size_t ann_id_b = b.annotation_collection.insert(std::make_shared(c_b, 1)); + b.delta.add(2, 'c', AnnotationState(2, ann_id_b)); + + // Compute the intersection (product) + Cntnfa result = intersection_counter_nfas(a, b); + + // It should have exactly one initial state from pair (0, 0) + REQUIRE(result.initial.size() == 1); + + // It should have one final state from pair (2, 2) + REQUIRE(!result.final.empty()); + + // Check transitions on a, b, c + bool has_a = false, has_b = false, has_c = false; + for (const auto& post : result.delta) { + for (const auto& sp : post) { + if (sp.symbol == 'a') has_a = true; + if (sp.symbol == 'b') has_b = true; + if (sp.symbol == 'c') has_c = true; + } + } + REQUIRE(has_a); + REQUIRE(has_b); + REQUIRE(has_c); + + // Check the counter set size + REQUIRE(result.counter_set.size() == 2); + + // Check the counter names + REQUIRE(result.counter_set.get_name(0) == "c0"); + REQUIRE(result.counter_set.get_name(1) == "c1"); + + // Check the number of states + REQUIRE(result.num_of_states() == 3); +} + +TEST_CASE("mata::cntnfa::union_norename()") { + Run one{{1},{}}; + Run zero{{0}, {}}; + + Cntnfa lhs(2); + lhs.initial.insert(0); + lhs.delta.add(0, 0, 1); + lhs.final.insert(1); + REQUIRE(!lhs.is_in_lang(one)); + REQUIRE(lhs.is_in_lang(zero)); + + Cntnfa rhs(2); + rhs.initial.insert(0); + rhs.delta.add(0, 1, 1); + rhs.final.insert(1); + REQUIRE(rhs.is_in_lang(one)); + REQUIRE(!rhs.is_in_lang(zero)); + + SECTION("failing minimal scenario") { + Cntnfa result = union_nondet(lhs, rhs); + REQUIRE(result.is_in_lang(one)); + REQUIRE(result.is_in_lang(zero)); + } +} + +TEST_CASE("mata::cntnfa::union_inplace") { + Run one{{1},{}}; + Run zero{{0}, {}}; + + Cntnfa lhs(2); + lhs.initial.insert(0); + lhs.delta.add(0, 0, 1); + lhs.final.insert(1); + REQUIRE(!lhs.is_in_lang(one)); + REQUIRE(lhs.is_in_lang(zero)); + + Cntnfa rhs(2); + rhs.initial.insert(0); + rhs.delta.add(0, 1, 1); + rhs.final.insert(1); + REQUIRE(rhs.is_in_lang(one)); + REQUIRE(!rhs.is_in_lang(zero)); + + SECTION("failing minimal scenario") { + Cntnfa result = lhs.unite_nondet_with(rhs); + REQUIRE(result.is_in_lang(one)); + REQUIRE(result.is_in_lang(zero)); + } + + SECTION("same automata") { + const Cntnfa lhs_copy{ lhs }; + CHECK(are_equivalent(lhs.unite_nondet_with(lhs), lhs_copy)); + } +} + +TEST_CASE("mata::cntnfa::union_product()") { + Run one{ { 1 },{} }; + Run zero{{ 0 }, {} }; + Run two{ { 2 },{} }; + Run two_three{ { 2, 3 },{} }; + + Cntnfa lhs(4); + lhs.initial.insert(0); + lhs.delta.add(0, 0, 1); + lhs.delta.add(0, 2, 2); + lhs.delta.add(2, 3, 3); + lhs.final.insert(1); + lhs.final.insert(3); + REQUIRE(!lhs.is_in_lang(one)); + REQUIRE(lhs.is_in_lang(zero)); + REQUIRE(!lhs.is_in_lang(two)); + REQUIRE(lhs.is_in_lang(two_three)); + + Cntnfa rhs(4); + rhs.initial.insert(0); + rhs.delta.add(0, 1, 1); + rhs.delta.add(0, 2, 2); + rhs.delta.add(2, 3, 3); + rhs.final.insert(1); + rhs.final.insert(2); + REQUIRE(rhs.is_in_lang(one)); + REQUIRE(!rhs.is_in_lang(zero)); + REQUIRE(rhs.is_in_lang(two)); + REQUIRE(!rhs.is_in_lang(two_three)); + + SECTION("Minimal example") { + Cntnfa result = mata::cntnfa::union_product(lhs, rhs); + CHECK(!result.is_in_lang(one)); + CHECK(!result.is_in_lang(zero)); + CHECK(result.is_in_lang(two)); + CHECK(result.is_in_lang(two_three)); + } +} + +TEST_CASE("mata::cntnfa::remove_final()") +{ + Cntnfa aut('q' + 1); + + SECTION("Automaton B") + { + FILL_WITH_AUT_B(aut); + REQUIRE(aut.final[2]); + REQUIRE(aut.final[12]); + aut.final.erase(12); + REQUIRE(aut.final[2]); + REQUIRE(!aut.final[12]); + } +} + +TEST_CASE("mata::cntnfa::delta.remove()") +{ + Cntnfa aut('q' + 1); + + SECTION("Automaton B") + { + FILL_WITH_AUT_B(aut); + aut.delta.add(1, 3, 4); + aut.delta.add(1, 3, 5); + + SECTION("Simple remove") + { + REQUIRE(aut.delta.contains(1, 3, 4)); + REQUIRE(aut.delta.contains(1, 3, 5)); + aut.delta.remove(1, 3, 5); + REQUIRE(aut.delta.contains(1, 3, 4)); + REQUIRE(!aut.delta.contains(1, 3, 5)); + } + + SECTION("Remove missing transition") + { + REQUIRE_THROWS_AS(aut.delta.remove(1, 1, 5), std::invalid_argument); + } + + SECTION("Remove the last state_to from targets") { + REQUIRE(aut.delta.contains(6, 'a', 2)); + aut.delta.remove(6, 'a', 2); + REQUIRE(!aut.delta.contains(6, 'a', 2)); + REQUIRE(aut.delta[6].empty()); + + REQUIRE(aut.delta.contains(4, 'a', 8)); + REQUIRE(aut.delta.contains(4, 'c', 8)); + REQUIRE(aut.delta.contains(4, 'a', 6)); + REQUIRE(aut.delta.contains(4, 'b', 6)); + REQUIRE(aut.delta[4].size() == 3); + aut.delta.remove(4, 'a', 6); + REQUIRE(!aut.delta.contains(4, 'a', 6)); + REQUIRE(aut.delta.contains(4, 'b', 6)); + REQUIRE(aut.delta[4].size() == 3); + + aut.delta.remove(4, 'a', 8); + REQUIRE(!aut.delta.contains(4, 'a', 8)); + REQUIRE(aut.delta.contains(4, 'c', 8)); + REQUIRE(aut.delta[4].size() == 2); + + aut.delta.remove(4, 'c', 8); + REQUIRE(!aut.delta.contains(4, 'a', 8)); + REQUIRE(!aut.delta.contains(4, 'c', 8)); + REQUIRE(aut.delta[4].size() == 1); + } + } +} + +TEST_CASE("mata::cntnfa::get_trans_as_sequence(}") { + Cntnfa aut('q' + 1); + std::vector expected{}; + + aut.delta.add(1, 2, 3); + expected.emplace_back(1, 2, 3); + aut.delta.add(1, 3, 4); + expected.emplace_back(1, 3, 4); + aut.delta.add(2, 3, 4); + expected.emplace_back(2, 3, 4); + + + const Delta::Transitions transitions{ aut.delta.transitions() }; + REQUIRE(std::vector{ transitions.begin(), transitions.end() } == expected); +} + +TEST_CASE("mata::cntnfa::remove_epsilon()") +{ + Cntnfa aut{20}; + FILL_WITH_AUT_A(aut); + aut.remove_epsilon('c'); + REQUIRE(aut.delta.contains(10, 'a', 7)); + REQUIRE(aut.delta.contains(10, 'b', 7)); + REQUIRE(!aut.delta.contains(10, 'c', 7)); + REQUIRE(aut.delta.contains(7, 'a', 5)); + REQUIRE(aut.delta.contains(7, 'a', 3)); + REQUIRE(!aut.delta.contains(7, 'c', 3)); + REQUIRE(aut.delta.contains(7, 'b', 9)); + REQUIRE(aut.delta.contains(7, 'a', 7)); + REQUIRE(aut.delta.contains(5, 'a', 5)); + REQUIRE(!aut.delta.contains(5, 'c', 9)); + REQUIRE(aut.delta.contains(5, 'a', 9)); +} + +TEST_CASE("Profile mata::cntnfa::remove_epsilon()", "[.profiling]") +{ + for (size_t n{}; n < 100000; ++n) { + Cntnfa aut{20}; + FILL_WITH_AUT_A(aut); + aut.remove_epsilon('c'); + } +} + +TEST_CASE("mata::cntnfa::get_num_of_trans()") +{ + Cntnfa aut{20}; + FILL_WITH_AUT_A(aut); + REQUIRE(aut.delta.num_of_transitions() == 15); +} + +TEST_CASE("mata::cntnfa::get_one_letter_aut()") +{ + Cntnfa aut(11); + Symbol abstract_symbol{'x'}; + FILL_WITH_AUT_A(aut); + + Cntnfa digraph{aut.get_one_letter_aut() }; + + REQUIRE(digraph.num_of_states() == aut.num_of_states()); + REQUIRE(digraph.delta.num_of_transitions() == 12); + REQUIRE(digraph.delta.contains(1, abstract_symbol, 10)); + REQUIRE(digraph.delta.contains(10, abstract_symbol, 7)); + REQUIRE(!digraph.delta.contains(10, 'a', 7)); + REQUIRE(!digraph.delta.contains(10, 'b', 7)); + REQUIRE(!digraph.delta.contains(10, 'c', 7)); +} + +TEST_CASE("mata::cntnfa::get_reachable_states()") { + Cntnfa aut{20}; + + SECTION("Automaton A") { + FILL_WITH_AUT_A(aut); + aut.delta.remove(3, 'b', 9); + aut.delta.remove(5, 'c', 9); + aut.delta.remove(1, 'a', 10); + + StateSet reachable{ aut.get_reachable_states() }; + CHECK(!reachable.contains(0)); + CHECK(reachable.contains(1)); + CHECK(!reachable.contains(2)); + CHECK(reachable.contains(3)); + CHECK(!reachable.contains(4)); + CHECK(reachable.contains(5)); + CHECK(!reachable.contains(6)); + CHECK(reachable.contains(7)); + CHECK(!reachable.contains(8)); + CHECK(!reachable.contains(9)); + CHECK(!reachable.contains(10)); + + aut.initial.erase(1); + aut.initial.erase(3); + reachable = aut.get_reachable_states(); + CHECK(reachable.empty()); + } + + SECTION("Automaton B") + { + FILL_WITH_AUT_B(aut); + aut.delta.remove(2, 'c', 12); + aut.delta.remove(4, 'c', 8); + aut.delta.remove(4, 'a', 8); + + auto reachable{aut.get_reachable_states()}; + CHECK(reachable.find(0) != reachable.end()); + CHECK(reachable.find(1) == reachable.end()); + CHECK(reachable.find(2) != reachable.end()); + CHECK(reachable.find(3) == reachable.end()); + CHECK(reachable.find(4) != reachable.end()); + CHECK(reachable.find(5) == reachable.end()); + CHECK(reachable.find(6) != reachable.end()); + CHECK(reachable.find(7) == reachable.end()); + CHECK(reachable.find(8) == reachable.end()); + CHECK(reachable.find(9) == reachable.end()); + CHECK(reachable.find(10) == reachable.end()); + CHECK(reachable.find(11) == reachable.end()); + CHECK(reachable.find(12) == reachable.end()); + CHECK(reachable.find(13) == reachable.end()); + CHECK(reachable.find(14) == reachable.end()); + + aut.final.erase(2); + reachable = aut.get_reachable_states(); + CHECK(reachable.size() == 4); + CHECK(reachable.find(0) != reachable.end()); + CHECK(reachable.find(2) != reachable.end()); + CHECK(reachable.find(4) != reachable.end()); + CHECK(reachable.find(6) != reachable.end()); + CHECK(aut.get_useful_states().count() == 0); + + aut.final.insert(4); + reachable = aut.get_reachable_states(); + CHECK(reachable.find(4) != reachable.end()); + } +} + +TEST_CASE("mata::cntnfa::trim() for profiling", "[.profiling],[trim]") +{ + Cntnfa aut{20}; + FILL_WITH_AUT_A(aut); + aut.delta.remove(1, 'a', 10); + + for (size_t i{ 0 }; i < 10000; ++i) { + Cntnfa new_aut{ aut }; + new_aut.trim(); + } +} + +// TODO: Make this a test for the new version. +TEST_CASE("mata::cntnfa::get_useful_states() for profiling", "[.profiling],[useful_states]") +{ + Cntnfa aut{20}; + FILL_WITH_AUT_A(aut); + aut.delta.remove(1, 'a', 10); + + for (size_t i{ 0 }; i < 10000; ++i) { + aut.get_useful_states(); + } +} + +TEST_CASE("mata::cntnfa::trim() trivial") { + Cntnfa aut{1}; + aut.initial.insert(0); + aut.final.insert(0); + aut.trim(); +} + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa::trim()") +// { +// Cntnfa orig_aut{20}; +// FILL_WITH_AUT_A(orig_aut); +// orig_aut.delta.remove(1, 'a', 10); + + +// SECTION("Without state map") { +// Cntnfa aut{orig_aut}; +// aut.trim(); +// CHECK(aut.initial.size() == orig_aut.initial.size()); +// CHECK(aut.final.size() == orig_aut.final.size()); +// CHECK(aut.num_of_states() == 4); +// for (const Word& word: get_shortest_words(orig_aut)) +// { +// CHECK(aut.is_in_lang(Run{word,{}})); +// } + +// aut.final.erase(2); // '2' is the new final state in the earlier trimmed automaton. +// aut.trim(); +// CHECK(aut.delta.empty()); +// CHECK(aut.num_of_states() == 0); +// } + +// SECTION("With state map") { +// Cntnfa aut{orig_aut}; +// StateRenaming state_map{}; +// aut.trim(&state_map); +// CHECK(aut.initial.size() == orig_aut.initial.size()); +// CHECK(aut.final.size() == orig_aut.final.size()); +// CHECK(aut.num_of_states() == 4); +// for (const Word& word: get_shortest_words(orig_aut)) +// { +// CHECK(aut.is_in_lang(Run{word,{}})); +// } +// REQUIRE(state_map.size() == 4); +// CHECK(state_map.at(1) == 0); +// CHECK(state_map.at(3) == 1); +// CHECK(state_map.at(7) == 3); +// CHECK(state_map.at(5) == 2); + +// aut.final.erase(2); // '2' is the new final state in the earlier trimmed automaton. +// aut.trim(&state_map); +// CHECK(aut.delta.empty()); +// CHECK(aut.num_of_states() == 0); +// CHECK(state_map.empty()); +// } +// } + +TEST_CASE("mata::cntnfa::Cntnfa::delta.empty()") +{ + Cntnfa aut{}; + + SECTION("Empty automaton") + { + CHECK(aut.delta.empty()); + } + + SECTION("No transitions automaton") + { + aut.add_state(); + CHECK(aut.delta.empty()); + } + + SECTION("Single state automaton with no transitions") + { + aut.add_state(); + aut.initial.insert(0); + aut.final.insert(0); + CHECK(aut.delta.empty()); + } + + SECTION("Single state automaton with transitions") + { + aut.add_state(); + aut.initial.insert(0); + aut.final.insert(0); + aut.delta.add(0, 'a', 0); + CHECK(!aut.delta.empty()); + } + + SECTION("Single state automaton with transitions") + { + aut.add_state(1); + aut.initial.insert(0); + aut.final.insert(1); + CHECK(aut.delta.empty()); + } + + SECTION("Single state automaton with transitions") + { + aut.add_state(1); + aut.initial.insert(0); + aut.final.insert(1); + aut.delta.add(0, 'a', 1); + CHECK(!aut.delta.empty()); + } +} + +TEST_CASE("mata::cntnfa::delta.operator[]") +{ + Cntnfa aut{20}; + FILL_WITH_AUT_A(aut); + REQUIRE(aut.delta.num_of_transitions() == 15); + aut.delta[25]; + REQUIRE(aut.num_of_states() == 20); + + aut.delta.mutable_state_post(25); + REQUIRE(aut.num_of_states() == 26); + REQUIRE(aut.delta[25].empty()); + + aut.delta.mutable_state_post(50); + REQUIRE(aut.num_of_states() == 51); + REQUIRE(aut.delta[50].empty()); + + Cntnfa aut1 = aut; + aut1.delta.mutable_state_post(60); + REQUIRE(aut1.num_of_states() == 61); + REQUIRE(aut1.delta[60].empty()); + + const Cntnfa aut2 = aut; + aut2.delta[60]; + REQUIRE(aut2.num_of_states() == 51); + REQUIRE(aut2.delta[60].empty()); +} + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa::Cntnfa::unify_(initial/final)()") { +// Cntnfa nfa{10}; + +// SECTION("No initial") { +// nfa.unify_initial(); +// CHECK(nfa.num_of_states() == 10); +// CHECK(nfa.initial.empty()); +// } + +// SECTION("initial==final unify final") { +// nfa.initial.insert(0); +// nfa.final.insert(0); +// nfa.final.insert(1); +// nfa.unify_final(); +// REQUIRE(nfa.num_of_states() == 11); +// CHECK(nfa.final.size() == 1); +// CHECK(nfa.final[10]); +// CHECK(nfa.initial[10]); +// } + +// SECTION("initial==final unify initial") { +// nfa.initial.insert(0); +// nfa.initial.insert(1); +// nfa.final.insert(0); +// nfa.unify_initial(); +// REQUIRE(nfa.num_of_states() == 11); +// CHECK(nfa.initial.size() == 1); +// CHECK(nfa.initial[10]); +// CHECK(nfa.final[10]); +// } + +// SECTION("Single initial") { +// nfa.initial.insert(0); +// nfa.unify_initial(); +// CHECK(nfa.num_of_states() == 10); +// CHECK(nfa.initial.size() == 1); +// CHECK(nfa.initial[0]); +// } + +// SECTION("Multiple initial") { +// nfa.initial.insert(0); +// nfa.initial.insert(1); +// nfa.unify_initial(); +// CHECK(nfa.num_of_states() == 11); +// CHECK(nfa.initial.size() == 1); +// CHECK(nfa.initial[10]); +// } + +// SECTION("With transitions") { +// nfa.initial.insert(0); +// nfa.initial.insert(1); +// nfa.delta.add(0, 'a', 3); +// nfa.delta.add(1, 'b', 0); +// nfa.delta.add(1, 'c', 1); +// nfa.unify_initial(); +// CHECK(nfa.num_of_states() == 11); +// CHECK(nfa.initial.size() == 1); +// CHECK(nfa.initial[10]); +// CHECK(nfa.delta.contains(10, 'a', 3)); +// CHECK(nfa.delta.contains(10, 'b', 0)); +// CHECK(nfa.delta.contains(10, 'c', 1)); +// CHECK(nfa.delta.contains(0, 'a', 3)); +// CHECK(nfa.delta.contains(1, 'b', 0)); +// CHECK(nfa.delta.contains(1, 'c', 1)); +// } + +// SECTION("No final") { +// nfa.unify_final(); +// CHECK(nfa.num_of_states() == 10); +// CHECK(nfa.final.empty()); +// } + +// SECTION("Single final") { +// nfa.final.insert(0); +// nfa.unify_final(); +// CHECK(nfa.num_of_states() == 10); +// CHECK(nfa.final.size() == 1); +// CHECK(nfa.final[0]); +// } + +// SECTION("Multiple final") { +// nfa.final.insert(0); +// nfa.final.insert(1); +// nfa.unify_final(); +// CHECK(nfa.num_of_states() == 11); +// CHECK(nfa.final.size() == 1); +// CHECK(nfa.final[10]); +// } + +// SECTION("With transitions") { +// nfa.final.insert(0); +// nfa.final.insert(1); +// nfa.delta.add(3, 'a', 0); +// nfa.delta.add(4, 'b', 1); +// nfa.delta.add(1, 'c', 1); +// nfa.unify_final(); +// CHECK(nfa.num_of_states() == 11); +// CHECK(nfa.final.size() == 1); +// CHECK(nfa.final[10]); +// CHECK(nfa.delta.contains(3, 'a', 10)); +// CHECK(nfa.delta.contains(4, 'b', 10)); +// CHECK(nfa.delta.contains(1, 'c', 10)); +// CHECK(nfa.delta.contains(3, 'a', 0)); +// CHECK(nfa.delta.contains(4, 'b', 1)); +// CHECK(nfa.delta.contains(1, 'c', 1)); +// } + +// SECTION("Bug: NFA with empty string unifying initial/final repeatedly") { +// Cntnfa aut; +// mata::parser::create_nfa(&aut, "a*b*"); +// for (size_t i{ 0 }; i < 8; ++i) { +// aut.unify_initial(); +// aut.unify_final(); +// } +// CHECK(true); // Check that the program does not seg fault. +// } +// } + +TEST_CASE("mata::cntnfa::Cntnfa::get_delta.epsilon_symbol_posts()") { + Cntnfa aut{20}; + FILL_WITH_AUT_A(aut); + aut.delta.add(0, EPSILON, 3); + aut.delta.add(3, EPSILON, 3); + aut.delta.add(3, EPSILON, 4); + + auto state_eps_trans{ aut.delta.epsilon_symbol_posts(0) }; + CHECK(state_eps_trans->symbol == EPSILON); + CHECK(state_eps_trans->targets == StateSet{3 }); + state_eps_trans = aut.delta.epsilon_symbol_posts(3); + CHECK(state_eps_trans->symbol == EPSILON); + CHECK(state_eps_trans->targets == StateSet{3, 4 }); + + aut.delta.add(8, 42, 3); + aut.delta.add(8, 42, 4); + aut.delta.add(8, 42, 6); + + state_eps_trans = aut.delta.epsilon_symbol_posts(8, 42); + CHECK(state_eps_trans->symbol == 42); + CHECK(state_eps_trans->targets == StateSet{3, 4, 6 }); + + CHECK(aut.delta.epsilon_symbol_posts(1) == aut.delta.state_post(1).end()); + CHECK(aut.delta.epsilon_symbol_posts(5) == aut.delta.state_post(5).end()); + CHECK(aut.delta.epsilon_symbol_posts(19) == aut.delta.state_post(19).end()); + + StatePost state_post{ aut.delta[0] }; + state_eps_trans = aut.delta.epsilon_symbol_posts(state_post); + CHECK(state_eps_trans->symbol == EPSILON); + CHECK(state_eps_trans->targets == StateSet{3 }); + state_post = aut.delta[3]; + state_eps_trans = Delta::epsilon_symbol_posts(state_post); + CHECK(state_eps_trans->symbol == EPSILON); + CHECK(state_eps_trans->targets == StateSet{3, 4 }); + + state_post = aut.delta.state_post(1); + CHECK(aut.delta.epsilon_symbol_posts(state_post) == state_post.end()); + state_post = aut.delta.state_post(5); + CHECK(aut.delta.epsilon_symbol_posts(state_post) == state_post.end()); + state_post = aut.delta.state_post(19); + CHECK(aut.delta.epsilon_symbol_posts(state_post) == state_post.end()); +} + +TEST_CASE("mata::cntnfa::Cntnfa::delta()") { + Delta delta(6); +} + +TEST_CASE("Cntnfa: A segmentation fault in the make_complement") { + Cntnfa r(1); + OnTheFlyAlphabet alph{}; + alph["a"]; + alph["b"]; + + r.initial = {0}; + r.delta.add(0, 0, 0); + REQUIRE(not r.is_complete(&alph)); + r.make_complete(&alph, 1); + REQUIRE(r.is_complete(&alph)); +} + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa:: create simple automata") { +// Cntnfa nfa{ builder::create_empty_string_nfa() }; +// CHECK(nfa.is_in_lang(Word{})); +// CHECK(get_word_lengths(nfa) == std::set>{ std::make_pair(0, 0) }); + +// OnTheFlyAlphabet alphabet{ { "a", 0 }, { "b", 1 }, { "c", 2 } }; +// nfa = builder::create_sigma_star_nfa(&alphabet); +// CHECK(nfa.is_in_lang({ {}, {} })); +// CHECK(nfa.is_in_lang({ 0 , {} })); +// CHECK(nfa.is_in_lang({ 1 , {} })); +// CHECK(nfa.is_in_lang({ 2 , {} })); +// CHECK(nfa.is_in_lang({ { 0, 1 }, {} })); +// CHECK(nfa.is_in_lang({ { 1, 0 }, {} })); +// CHECK(nfa.is_in_lang({ { 2, 2, 2 }, {} })); +// CHECK(nfa.is_in_lang({ { 0, 1, 2, 2, 0, 1, 2, 1, 0, 0, 2, 1 }, {} })); +// CHECK(!nfa.is_in_lang({ 3 , {} })); +// } + +TEST_CASE("mata::cntnfa:: print_to_mata") { + Cntnfa aut_big; + aut_big.initial = {1, 2}; + aut_big.delta.add(1, 'a', 2); + aut_big.delta.add(1, 'a', 3); + aut_big.delta.add(1, 'b', 4); + aut_big.delta.add(2, 'a', 2); + aut_big.delta.add(2, 'b', 2); + aut_big.delta.add(2, 'a', 3); + aut_big.delta.add(2, 'b', 4); + aut_big.delta.add(3, 'b', 4); + aut_big.delta.add(3, 'c', 7); + aut_big.delta.add(3, 'b', 2); + aut_big.delta.add(5, 'c', 3); + aut_big.delta.add(7, 'a', 8); + aut_big.final = {3}; + + std::string aut_big_mata = aut_big.print_to_mata(); + // for parsing output of print_to_mata() we need to use IntAlphabet to get the same alphabet + IntAlphabet int_alph; + Cntnfa aut_big_from_mata = builder::construct(mata::IntermediateAut::parse_from_mf(parse_mf(aut_big_mata))[0], &int_alph); + + CHECK(are_equivalent(aut_big, aut_big_from_mata)); +} + +TEST_CASE("mata::cntnfa::Cntnfa::trim() bug") { + Cntnfa aut(5, {0}, {4}); + aut.delta.add(0, 122, 1); + aut.delta.add(1, 98, 1); + aut.delta.add(1, 122, 1); + aut.delta.add(1, 97, 2); + aut.delta.add(2, 122, 1); + aut.delta.add(2, 97, 1); + aut.delta.add(1, 97, 4); + aut.delta.add(3, 97, 4); + + Cntnfa aut_copy {aut}; + CHECK(are_equivalent(aut_copy.trim(), aut)); +} + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa::get_useful_states_tarjan") { +// SECTION("Cntnfa 1") { +// Cntnfa aut(5, {0}, {4}); +// aut.delta.add(0, 122, 1); +// aut.delta.add(1, 98, 1); +// aut.delta.add(1, 122, 1); +// aut.delta.add(1, 97, 2); +// aut.delta.add(2, 122, 1); +// aut.delta.add(2, 97, 1); +// aut.delta.add(1, 97, 4); +// aut.delta.add(3, 97, 4); + +// mata::BoolVector bv = aut.get_useful_states(); +// mata::BoolVector ref({ 1, 1, 1, 0, 1}); +// CHECK(bv == ref); +// } + +// SECTION("Empty NFA") { +// Cntnfa aut; +// mata::BoolVector bv = aut.get_useful_states(); +// CHECK(bv == mata::BoolVector({})); +// } + +// SECTION("Single-state NFA") { +// Cntnfa aut(1, {0}, {}); +// mata::BoolVector bv = aut.get_useful_states(); +// CHECK(bv == mata::BoolVector({ 0})); +// } + +// SECTION("Single-state NFA acc") { +// Cntnfa aut(1, {0}, {0}); +// mata::BoolVector bv = aut.get_useful_states(); +// CHECK(bv == mata::BoolVector({ 1})); +// } + +// SECTION("Cntnfa 2") { +// Cntnfa aut(5, {0, 1}, {2}); +// aut.delta.add(0, 122, 2); +// aut.delta.add(2, 98, 3); +// aut.delta.add(1, 98, 4); +// aut.delta.add(4, 97, 3); + +// mata::BoolVector bv = aut.get_useful_states(); +// mata::BoolVector ref({ 1, 0, 1, 0, 0}); +// CHECK(bv == ref); +// } + +// SECTION("Cntnfa 3") { +// Cntnfa aut(2, {0, 1}, {0, 1}); +// aut.delta.add(0, 122, 0); +// aut.delta.add(1, 98, 1); + +// mata::BoolVector bv = aut.get_useful_states(); +// mata::BoolVector ref({ 1, 1}); +// CHECK(bv == ref); +// } + +// SECTION("Cntnfa no final") { +// Cntnfa aut(5, {0}, {}); +// aut.delta.add(0, 122, 1); +// aut.delta.add(1, 98, 1); +// aut.delta.add(1, 122, 1); +// aut.delta.add(1, 97, 2); +// aut.delta.add(2, 122, 1); +// aut.delta.add(2, 97, 1); +// aut.delta.add(1, 97, 4); +// aut.delta.add(3, 97, 4); + +// mata::BoolVector bv = aut.get_useful_states(); +// mata::BoolVector ref({ 0, 0, 0, 0, 0}); +// CHECK(bv == ref); +// } + +// SECTION("from regex (a+b*a*)") { +// Cntnfa aut; +// mata::parser::create_nfa(&aut, "(a+b*a*)", false, EPSILON, false); + +// mata::BoolVector bv = aut.get_useful_states(); +// mata::BoolVector ref({ 1, 0, 1, 0, 1, 0, 1, 0, 0}); +// CHECK(bv == ref); + +// aut = reduce(aut.trim()); +// bv = aut.get_useful_states(); +// CHECK(bv == mata::BoolVector({ 1, 1, 1, 1})); +// } + +// SECTION("more initials") { +// Cntnfa aut(4, {0, 1, 2}, {0, 3}); +// aut.delta.add(1, 48, 0); +// aut.delta.add(2, 53, 3); +// CHECK(aut.get_useful_states() == mata::BoolVector{ 1, 1, 1, 1}); +// } +// } + +TEST_CASE("mata::cntnfa::Cntnfa::get_words") { + SECTION("empty") { + Cntnfa aut; + CHECK(aut.get_words(0) == std::set()); + CHECK(aut.get_words(1) == std::set()); + CHECK(aut.get_words(5) == std::set()); + } + + SECTION("empty word") { + Cntnfa aut(1, {0}, {0}); + CHECK(aut.get_words(0) == std::set{{}}); + CHECK(aut.get_words(1) == std::set{{}}); + CHECK(aut.get_words(5) == std::set{{}}); + } + + SECTION("noodle - one final") { + Cntnfa aut(3, {0}, {2}); + aut.delta.add(0, 0, 1); + aut.delta.add(1, 1, 2); + CHECK(aut.get_words(0) == std::set{}); + CHECK(aut.get_words(1) == std::set{}); + CHECK(aut.get_words(2) == std::set{{0, 1}}); + CHECK(aut.get_words(3) == std::set{{0, 1}}); + CHECK(aut.get_words(5) == std::set{{0, 1}}); + } + + SECTION("noodle - two finals") { + Cntnfa aut(3, {0}, {1,2}); + aut.delta.add(0, 0, 1); + aut.delta.add(1, 1, 2); + CHECK(aut.get_words(0) == std::set{}); + CHECK(aut.get_words(1) == std::set{{0}}); + CHECK(aut.get_words(2) == std::set{{0}, {0, 1}}); + CHECK(aut.get_words(3) == std::set{{0}, {0, 1}}); + CHECK(aut.get_words(5) == std::set{{0}, {0, 1}}); + } + + SECTION("noodle - three finals") { + Cntnfa aut(3, {0}, {0,1,2}); + aut.delta.add(0, 0, 1); + aut.delta.add(1, 1, 2); + CHECK(aut.get_words(0) == std::set{{}}); + CHECK(aut.get_words(1) == std::set{{}, {0}}); + CHECK(aut.get_words(2) == std::set{{}, {0}, {0, 1}}); + CHECK(aut.get_words(3) == std::set{{}, {0}, {0, 1}}); + CHECK(aut.get_words(5) == std::set{{}, {0}, {0, 1}}); + } + + SECTION("more complex") { + Cntnfa aut(6, {0,1}, {1,3,4,5}); + aut.delta.add(0, 0, 3); + aut.delta.add(3, 1, 4); + aut.delta.add(0, 2, 2); + aut.delta.add(3, 3, 2); + aut.delta.add(1, 4, 2); + aut.delta.add(2, 5, 5); + CHECK(aut.get_words(0) == std::set{{}}); + CHECK(aut.get_words(1) == std::set{{}, {0}}); + CHECK(aut.get_words(2) == std::set{{}, {0}, {0, 1}, {2,5}, {4,5}}); + CHECK(aut.get_words(3) == std::set{{}, {0}, {0, 1}, {2,5}, {4,5}, {0,3,5}}); + CHECK(aut.get_words(4) == std::set{{}, {0}, {0, 1}, {2,5}, {4,5}, {0,3,5}}); + CHECK(aut.get_words(5) == std::set{{}, {0}, {0, 1}, {2,5}, {4,5}, {0,3,5}}); + } + + SECTION("cycle") { + Cntnfa aut(6, {0,1}, {0,1}); + aut.delta.add(0, 0, 1); + aut.delta.add(1, 1, 0); + CHECK(aut.get_words(0) == std::set{{}}); + CHECK(aut.get_words(1) == std::set{{}, {0}, {1}}); + CHECK(aut.get_words(2) == std::set{{}, {0}, {1}, {0, 1}, {1, 0}}); + CHECK(aut.get_words(3) == std::set{{}, {0}, {1}, {0, 1}, {1, 0}, {0,1,0}, {1,0,1}}); + CHECK(aut.get_words(4) == std::set{{}, {0}, {1}, {0, 1}, {1, 0}, {0,1,0}, {1,0,1}, {0,1,0,1}, {1,0,1,0}}); + CHECK(aut.get_words(5) == std::set{{}, {0}, {1}, {0, 1}, {1, 0}, {0,1,0}, {1,0,1}, {0,1,0,1}, {1,0,1,0}, {0,1,0,1,0}, {1,0,1,0,1}}); + } +} + +TEST_CASE("mata::cntnfa::Cntnfa::get_word()") { + SECTION("empty") { + Cntnfa aut; + CHECK(aut.get_word(0) == std::nullopt); + } + + SECTION("empty word") { + Cntnfa aut(1, { 0 }, { 0 }); + CHECK(aut.get_word() == Word{}); + } + + SECTION("noodle - one final") { + Cntnfa aut(3, { 0 }, { 2 }); + aut.delta.add(0, 0, 1); + aut.delta.add(1, 1, 2); + CHECK(aut.get_word() == Word{ 0, 1 }); + } + + SECTION("noodle - two finals") { + Cntnfa aut(3, { 0 }, { 1, 2 }); + aut.delta.add(0, 0, 1); + aut.delta.add(1, 1, 2); + CHECK(aut.get_word() == Word{ 0 }); + } + + SECTION("noodle - three finals") { + Cntnfa aut(3, { 0 }, { 0, 1, 2 }); + aut.delta.add(0, 0, 1); + aut.delta.add(1, 1, 2); + CHECK(aut.get_word() == Word{}); + } + + SECTION("more complex initial final") { + Cntnfa aut(6, { 0, 1 }, { 1, 3, 4, 5 }); + aut.delta.add(0, 0, 3); + aut.delta.add(3, 1, 4); + aut.delta.add(0, 2, 2); + aut.delta.add(3, 3, 2); + aut.delta.add(1, 4, 2); + aut.delta.add(2, 5, 5); + CHECK(aut.get_word() == Word{}); + } + + SECTION("more complex") { + Cntnfa aut(6, { 0, 1 }, { 5 }); + aut.delta.add(0, 0, 3); + aut.delta.add(3, 1, 4); + aut.delta.add(0, 2, 2); + aut.delta.add(3, 3, 2); + aut.delta.add(1, 4, 2); + aut.delta.add(2, 5, 5); + CHECK(aut.get_word() == Word{ 0, 3, 5 }); + } + + SECTION("cycle") { + Cntnfa aut(6, { 0, 2 }, { 4 }); + aut.delta.add(2, 2, 3); + aut.delta.add(3, 3, 2); + aut.delta.add(0, 0, 1); + aut.delta.add(1, 1, 4); + CHECK(aut.get_word() == Word{ 0, 1 }); + } + + SECTION("epsilons") { + Cntnfa aut(6, { 0, 2 }, { 4 }); + aut.delta.add(2, 2, 3); + aut.delta.add(3, 3, 2); + aut.delta.add(0, EPSILON, 1); + aut.delta.add(1, 1, 4); + CHECK(aut.get_word() == Word{ 1 }); + } + + SECTION("Complex automaton with self loops, epsilons, and nonterminating states") { + Cntnfa aut{}; + aut.initial = { 0 }; + aut.final = { 4 }; + aut.delta.add(0, 'a', 0); + aut.delta.add(0, 'b', 1); + aut.delta.add(1, 'b', 1); + aut.delta.add(0, 'b', 2); + aut.delta.add(2, EPSILON, 3); + aut.delta.add(2, EPSILON, 1); + aut.delta.add(2, 'a', 0); + aut.delta.add(2, 'a', 2); + aut.delta.add(3, 'a', 5); + aut.delta.add(3, 'c', 4); + aut.delta.add(4, 'a', 4); + CHECK(aut.get_word() == Word{ 'b', 'c' }); + } + + SECTION("Complex automaton with self loops, epsilons, and nonterminating states, one separate final") { + Cntnfa aut{}; + aut.initial = { 0, 6 }; + aut.final = { 7 }; + aut.delta.add(6, 'd', 7); + aut.delta.add(0, 'a', 0); + aut.delta.add(0, 'b', 1); + aut.delta.add(1, 'b', 1); + aut.delta.add(0, 'b', 2); + aut.delta.add(2, EPSILON, 3); + aut.delta.add(2, EPSILON, 1); + aut.delta.add(2, 'a', 0); + aut.delta.add(2, 'a', 2); + aut.delta.add(3, 'a', 5); + aut.delta.add(3, 'c', 4); + aut.delta.add(4, 'a', 4); + CHECK(aut.get_word() == Word{ 'd' }); + } + + SECTION("Break after finding the first final without iterating over other initial states") { + Cntnfa aut{}; + aut.initial = { 0, 1 }; + aut.final = { 4, 5 }; + aut.delta.add(0, 'a', 2); + aut.delta.add(2, 'c', 4); + aut.delta.add(1, 'd', 3); + aut.delta.add(3, 'd', 5); + CHECK(aut.get_word() == Word{ 'a', 'c' }); + } + + SECTION("Complex automaton with self loops, epsilons, and nonterminating states, no reachable final") { + Cntnfa aut{}; + aut.initial = { 0 }; + aut.final = { 6 }; + aut.delta.add(0, 'a', 0); + aut.delta.add(0, 'b', 1); + aut.delta.add(1, 'b', 1); + aut.delta.add(0, 'b', 2); + aut.delta.add(2, EPSILON, 3); + aut.delta.add(2, EPSILON, 1); + aut.delta.add(2, 'a', 0); + aut.delta.add(2, 'a', 2); + aut.delta.add(3, 'a', 5); + aut.delta.add(3, 'c', 4); + aut.delta.add(4, 'a', 4); + CHECK(!aut.get_word().has_value()); + } + + SECTION("Complex automaton with self loops, epsilons, and nonterminating states, first initial nonterminating") { + Cntnfa aut{}; + aut.initial = { 1, 2 }; + aut.final = { 4 }; + aut.delta.add(0, 'a', 0); + aut.delta.add(0, 'b', 1); + aut.delta.add(1, 'b', 1); + aut.delta.add(0, 'b', 2); + aut.delta.add(2, EPSILON, 3); + aut.delta.add(2, EPSILON, 1); + aut.delta.add(2, 'a', 0); + aut.delta.add(2, 'a', 2); + aut.delta.add(3, 'a', 5); + aut.delta.add(3, 'c', 4); + aut.delta.add(4, 'a', 4); + CHECK(aut.get_word() == Word{ 'c' }); + } + + SECTION("Complex automaton with self loops, epsilons, and nonterminating states, long nonterminating sequence") { + Cntnfa aut{}; + aut.initial = { 0 }; + aut.final = { 2 }; + aut.delta.add(0, 'a', 0); + aut.delta.add(0, 'b', 2); + aut.delta.add(1, 'b', 1); + aut.delta.add(0, 'b', 1); + aut.delta.add(1, EPSILON, 3); + aut.delta.add(1, 'a', 0); + aut.delta.add(1, 'a', 1); + aut.delta.add(3, 'a', 5); + aut.delta.add(3, 'c', 4); + aut.delta.add(4, 'a', 4); + CHECK(aut.get_word() == Word{ 'b' }); + } +} + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa::Cntnfa::insert_word()") { +// Delta delta; +// delta.add(0, 0, 1); +// delta.add(0, 4, 0); +// delta.add(1, 1, 2); +// delta.add(1, 5, 1); +// delta.add(2, 2, 3); +// delta.add(2, 6, 2); +// delta.add(3, 3, 4); +// delta.add(3, 7, 3); + +// Cntnfa nfa, expected; + +// SECTION("Insert 'a'") { +// SECTION("src < tgt") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(1, {'a'}, 3); +// CHECK(new_tgt == 3); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(1, 'a', 3); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("src < tgt && final.contains(tgt)") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(1, {'a'}, 4); +// CHECK(new_tgt == 4); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(1, 'a', 4); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("tgt < src") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(3, {'a'}, 1); +// CHECK(new_tgt == 1); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(3, 'a', 1); + +// CHECK(are_equivalent(nfa, expected)); + +// } + +// SECTION("tgt < src && final.contains(tgt)") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(4, {'a'}, 1); +// CHECK(new_tgt == 1); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(4, 'a', 1); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("self-loop") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(3, {'a'}, 3); +// CHECK(new_tgt == 3); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(3, 'a', 3); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("self-loop && final.contains(tgt)") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(4, {'a'}, 4); +// CHECK(new_tgt == 4); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(4, 'a', 4); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("tgt is not specified") { +// nfa = Cntnfa(delta, { 0 }); +// State new_tgt = nfa.insert_word(1, {'a'}); +// nfa.final.insert(new_tgt); + +// expected = Cntnfa(3, { 0 }, { 2 }); +// expected.delta.add(0, 0, 1); +// expected.delta.add(0, 4, 0); +// expected.delta.add(1, 5, 1); +// expected.delta.add(1, 'a', 2); + +// CHECK(are_equivalent(nfa, expected)); +// } +// } + +// SECTION("Insert 'ab'") { +// SECTION("src < tgt") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(1, {'a', 'b'}, 3); +// CHECK(new_tgt == 3); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(1, 'a', 5); +// expected.delta.add(5, 'b', 3); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("src < tgt && final.contains(tgt)") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(1, {'a', 'b'}, 4); +// CHECK(new_tgt == 4); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(1, 'a', 5); +// expected.delta.add(5, 'b', 4); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("tgt < src") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(3, {'a', 'b'}, 1); +// CHECK(new_tgt == 1); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(3, 'a', 5); +// expected.delta.add(5, 'b', 1); + +// CHECK(are_equivalent(nfa, expected)); + +// } + +// SECTION("tgt < src && final.contains(tgt)") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(4, {'a', 'b'}, 1); +// CHECK(new_tgt == 1); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(4, 'a', 5); +// expected.delta.add(5, 'b', 1); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("self-loop") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(3, {'a', 'b'}, 3); +// CHECK(new_tgt == 3); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(3, 'a', 5); +// expected.delta.add(5, 'b', 3); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("self-loop && final.contains(tgt)") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(4, {'a', 'b'}, 4); +// CHECK(new_tgt == 4); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(4, 'a', 5); +// expected.delta.add(5, 'b', 4); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("tgt is not specified") { +// nfa = Cntnfa(delta, { 0 }); +// State new_tgt = nfa.insert_word(1, {'a', 'b'}); +// nfa.final.insert(new_tgt); + +// expected = Cntnfa(4, { 0 }, { 3 }); +// expected.delta.add(0, 0, 1); +// expected.delta.add(0, 4, 0); +// expected.delta.add(1, 5, 1); +// expected.delta.add(1, 'a', 2); +// expected.delta.add(2, 'b', 3); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// } + +// SECTION("Insert 'abcd'") { +// SECTION("src < tgt") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(1, {'a', 'b', 'c', 'd'}, 3); +// CHECK(new_tgt == 3); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(1, 'a', 5); +// expected.delta.add(5, 'b', 6); +// expected.delta.add(6, 'c', 7); +// expected.delta.add(7, 'd', 3); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("src < tgt && final.contains(tgt)") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(1, {'a', 'b', 'c', 'd'}, 4); +// CHECK(new_tgt == 4); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(1, 'a', 5); +// expected.delta.add(5, 'b', 6); +// expected.delta.add(6, 'c', 7); +// expected.delta.add(7, 'd', 4); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("tgt < src") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(3, {'a', 'b', 'c', 'd'}, 1); +// CHECK(new_tgt == 1); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(3, 'a', 5); +// expected.delta.add(5, 'b', 6); +// expected.delta.add(6, 'c', 7); +// expected.delta.add(7, 'd', 1); + +// CHECK(are_equivalent(nfa, expected)); + +// } + +// SECTION("tgt < src && final.contains(tgt)") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(4, {'a', 'b', 'c', 'd'}, 1); +// CHECK(new_tgt == 1); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(4, 'a', 5); +// expected.delta.add(5, 'b', 6); +// expected.delta.add(6, 'c', 7); +// expected.delta.add(7, 'd', 1); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("self-loop") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(3, {'a', 'b', 'c', 'd'}, 3); +// CHECK(new_tgt == 3); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(3, 'a', 5); +// expected.delta.add(5, 'b', 6); +// expected.delta.add(6, 'c', 7); +// expected.delta.add(7, 'd', 3); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("self-loop && final.contains(tgt)") { +// nfa = Cntnfa(delta, { 0 }, { 4 }); +// State new_tgt = nfa.insert_word(4, {'a', 'b', 'c', 'd'}, 4); +// CHECK(new_tgt == 4); + +// expected = Cntnfa(delta, { 0 }, { 4 }); +// expected.delta.add(4, 'a', 5); +// expected.delta.add(5, 'b', 6); +// expected.delta.add(6, 'c', 7); +// expected.delta.add(7, 'd', 4); + +// CHECK(are_equivalent(nfa, expected)); +// } + +// SECTION("tgt is not specified") { +// nfa = Cntnfa(delta, { 0 }); +// State new_tgt = nfa.insert_word(1, {'a', 'b', 'c', 'd'}); +// nfa.final.insert(new_tgt); + +// expected = Cntnfa(6, { 0 }, { 5 }); +// expected.delta.add(0, 0, 1); +// expected.delta.add(0, 4, 0); +// expected.delta.add(1, 5, 1); +// expected.delta.add(1, 'a', 2); +// expected.delta.add(2, 'b', 3); +// expected.delta.add(3, 'c', 4); +// expected.delta.add(4, 'd', 5); + +// CHECK(are_equivalent(nfa, expected)); +// } +// } +// } + +/// TODO: Update this test for cntnfa. +// TEST_CASE("mata::cntnfa::Cntnfa::decode_utf8") { +// SECTION("Empty") { +// Cntnfa aut; +// CHECK(are_equivalent(aut, aut.decode_utf8())); +// } + +// SECTION("Empty language") { +// Cntnfa aut(1, {0}, {0}); +// CHECK(are_equivalent(aut, aut.decode_utf8())); +// } + +// SECTION("between 0x00 and 0x7F") { +// Cntnfa aut; +// aut.initial.insert(0); +// aut.delta.add(0, 0x01, 1); +// aut.delta.add(1, 0x10, 2); +// aut.delta.add(2, 0x20, 3); +// aut.delta.add(3, 0x30, 4); +// aut.delta.add(4, 0x40, 5); +// aut.delta.add(5, 0x50, 6); +// aut.delta.add(6, 0x60, 7); +// aut.delta.add(7, 0x70, 8); +// aut.delta.add(8, 0x7f, 9); +// aut.final.insert(9); + +// Cntnfa result; +// result.initial.insert(0); +// result.delta.add(0, 0x01, 1); +// result.delta.add(1, 0x10, 2); +// result.delta.add(2, 0x20, 3); +// result.delta.add(3, 0x30, 4); +// result.delta.add(4, 0x40, 5); +// result.delta.add(5, 0x50, 6); +// result.delta.add(6, 0x60, 7); +// result.delta.add(7, 0x70, 8); +// result.delta.add(8, 0x7f, 9); +// result.final.insert(9); +// CHECK(are_equivalent(result, aut.decode_utf8())); +// } + +// SECTION("between 0x80 and 0x7ff") { +// Cntnfa aut; +// aut.initial.insert(0); +// aut.delta.add(0, 0xc2, 1); +// aut.delta.add(1, 0x80, 2); +// aut.delta.add(2, 0xc2, 3); +// aut.delta.add(3, 0x90, 4); +// aut.delta.add(4, 0xc2, 5); +// aut.delta.add(5, 0xa0, 6); +// aut.delta.add(6, 0xc2, 7); +// aut.delta.add(7, 0xb0, 8); +// aut.delta.add(8, 0xc3, 9); +// aut.delta.add(9, 0x80, 10); +// aut.delta.add(10, 0xc3, 11); +// aut.delta.add(11, 0x90, 12); +// aut.delta.add(12, 0xd8, 13); +// aut.delta.add(13, 0x80, 14); +// aut.delta.add(14, 0xdc, 15); +// aut.delta.add(15, 0x80, 16); +// aut.delta.add(16, 0xdf, 17); +// aut.delta.add(17, 0xbf, 18); +// aut.final.insert(18); + +// Cntnfa result; +// result.initial.insert(0); +// result.delta.add(0, 0x80, 1); +// result.delta.add(1, 0x90, 2); +// result.delta.add(2, 0xa0, 3); +// result.delta.add(3, 0xb0, 4); +// result.delta.add(4, 0xc0, 5); +// result.delta.add(5, 0xd0, 6); +// result.delta.add(6, 0x600, 7); +// result.delta.add(7, 0x700, 8); +// result.delta.add(8, 0x7ff, 9); +// result.final.insert(9); +// CHECK(are_equivalent(result, aut.decode_utf8())); +// } + +// SECTION("between 0x800 and 0x7FFF") { +// Cntnfa aut; +// aut.initial.insert(0); +// aut.delta.add(0, 0xe0, 1); +// aut.delta.add(1, 0xa0, 2); +// aut.delta.add(2, 0x80, 3); +// aut.delta.add(3, 0xe0, 4); +// aut.delta.add(4, 0xa4, 5); +// aut.delta.add(5, 0x80, 6); +// aut.delta.add(6, 0xe0, 7); +// aut.delta.add(7, 0xa8, 8); +// aut.delta.add(8, 0x80, 9); +// aut.delta.add(9, 0xe0, 10); +// aut.delta.add(10, 0xac, 11); +// aut.delta.add(11, 0x80, 12); +// aut.delta.add(12, 0xe0, 13); +// aut.delta.add(13, 0xb0, 14); +// aut.delta.add(14, 0x80, 15); +// aut.delta.add(15, 0xe0, 16); +// aut.delta.add(16, 0xb4, 17); +// aut.delta.add(17, 0x80, 18); +// aut.delta.add(18, 0xe6, 19); +// aut.delta.add(19, 0x80, 20); +// aut.delta.add(20, 0x80, 21); +// aut.delta.add(21, 0xe7, 22); +// aut.delta.add(22, 0x80, 23); +// aut.delta.add(23, 0x80, 24); +// aut.delta.add(24, 0xe7, 25); +// aut.delta.add(25, 0xbf, 26); +// aut.delta.add(26, 0xbf, 27); +// aut.final.insert(27); + +// Cntnfa result; +// result.initial.insert(0); +// result.delta.add(0, 0x800, 1); +// result.delta.add(1, 0x900, 2); +// result.delta.add(2, 0xa00, 3); +// result.delta.add(3, 0xb00, 4); +// result.delta.add(4, 0xc00, 5); +// result.delta.add(5, 0xd00, 6); +// result.delta.add(6, 0x6000, 7); +// result.delta.add(7, 0x7000, 8); +// result.delta.add(8, 0x7fff, 9); +// result.final.insert(9); +// CHECK(are_equivalent(result, aut.decode_utf8())); +// } + +// SECTION("between 0x10000 and 0x10FFFF") { +// Cntnfa aut; +// aut.initial.insert(0); +// aut.delta.add(0, 0xf0, 1); +// aut.delta.add(1, 0x90, 2); +// aut.delta.add(2, 0x80, 3); +// aut.delta.add(3, 0x80, 4); +// aut.delta.add(4, 0xf0, 5); +// aut.delta.add(5, 0xa0, 6); +// aut.delta.add(6, 0x80, 7); +// aut.delta.add(7, 0x80, 8); +// aut.delta.add(8, 0xf0, 9); +// aut.delta.add(9, 0xb0, 10); +// aut.delta.add(10, 0x80, 11); +// aut.delta.add(11, 0x80, 12); +// aut.delta.add(12, 0xf1, 13); +// aut.delta.add(13, 0x80, 14); +// aut.delta.add(14, 0x80, 15); +// aut.delta.add(15, 0x80, 16); +// aut.delta.add(16, 0xf1, 17); +// aut.delta.add(17, 0x90, 18); +// aut.delta.add(18, 0x80, 19); +// aut.delta.add(19, 0x80, 20); +// aut.delta.add(20, 0xf1, 21); +// aut.delta.add(21, 0xa0, 22); +// aut.delta.add(22, 0x80, 23); +// aut.delta.add(23, 0x80, 24); +// aut.delta.add(24, 0xf1, 25); +// aut.delta.add(25, 0xb0, 26); +// aut.delta.add(26, 0x80, 27); +// aut.delta.add(27, 0x80, 28); +// aut.delta.add(28, 0xf2, 29); +// aut.delta.add(29, 0x80, 30); +// aut.delta.add(30, 0x80, 31); +// aut.delta.add(31, 0x80, 32); +// aut.delta.add(32, 0xf4, 33); +// aut.delta.add(33, 0x8f, 34); +// aut.delta.add(34, 0xbf, 35); +// aut.delta.add(35, 0xbf, 36); +// aut.final.insert(36); + +// Cntnfa result; +// result.initial.insert(0); +// result.delta.add(0, 0x10000, 1); +// result.delta.add(1, 0x20000, 2); +// result.delta.add(2, 0x30000, 3); +// result.delta.add(3, 0x40000, 4); +// result.delta.add(4, 0x50000, 5); +// result.delta.add(5, 0x60000, 6); +// result.delta.add(6, 0x70000, 7); +// result.delta.add(7, 0x80000, 8); +// result.delta.add(8, 0x10ffff, 9); +// result.final.insert(9); +// CHECK(are_equivalent(result, aut.decode_utf8())); +// } + +// SECTION("mix") { +// Cntnfa aut; +// aut.initial.insert(0); +// aut.delta.add(0, 0x01, 1); +// aut.delta.add(1, 0xc2, 2); +// aut.delta.add(2, 0x90, 3); +// aut.delta.add(3, 0xe0, 4); +// aut.delta.add(4, 0xa2, 5); +// aut.delta.add(5, 0xac, 6); +// aut.delta.add(6, 0xf0, 7); +// aut.delta.add(7, 0x90, 8); +// aut.delta.add(8, 0x83, 9); +// aut.delta.add(9, 0x8c, 10); +// aut.final.insert(10); + +// Cntnfa result; +// result.initial.insert(0); +// result.delta.add(0, 0x01, 1); +// result.delta.add(1, 0x90, 2); +// result.delta.add(2, 0x8ac, 3); +// result.delta.add(3, 0x100cc, 4); +// result.final.insert(4); +// CHECK(are_equivalent(result, aut.decode_utf8())); +// } +// } diff --git a/tests/cntnfa/delta.cc b/tests/cntnfa/delta.cc new file mode 100644 index 000000000..d3ea6482e --- /dev/null +++ b/tests/cntnfa/delta.cc @@ -0,0 +1,482 @@ +// TODO: some header + +#include "mata/alphabet.hh" +#include "mata/cntnfa/types.hh" +#include "mata/cntnfa/delta.hh" +#include "mata/cntnfa/cntnfa.hh" + +#include +#include + +using namespace mata::cntnfa; + +using Symbol = mata::Symbol; + +TEST_CASE("mata::cntnfa::SymbolPost") { + CHECK(SymbolPost{ 0, StateSet{} } == SymbolPost{ 0, StateSet{ 0, 1 } }); + CHECK(SymbolPost{ 1, StateSet{} } != SymbolPost{ 0, StateSet{} }); + CHECK(SymbolPost{ 0, StateSet{ 1 } } < SymbolPost{ 1, StateSet{} }); + CHECK(SymbolPost{ 0, StateSet{ 1 } } <= SymbolPost{ 1, StateSet{} }); + CHECK(SymbolPost{ 0, StateSet{ 1 } } <= SymbolPost{ 0, StateSet{} }); + CHECK(SymbolPost{ 1, StateSet{ 0 } } > SymbolPost{ 0, StateSet{ 1 } }); + CHECK(SymbolPost{ 1, StateSet{ 0 } } >= SymbolPost{ 0, StateSet{ 1 } }); + CHECK(SymbolPost{ 1, StateSet{ 0 } } >= SymbolPost{ 0, StateSet{ 1 } }); +} + +TEST_CASE("mata::cntnfa::Delta::state_post()") { + Cntnfa aut{}; + + SECTION("Add new states within the limit") { + aut.add_state(19); + aut.initial.insert(0); + aut.initial.insert(1); + aut.initial.insert(2); + REQUIRE_NOTHROW(aut.delta.state_post(0)); + REQUIRE_NOTHROW(aut.delta.state_post(1)); + REQUIRE_NOTHROW(aut.delta.state_post(2)); + REQUIRE(aut.delta.state_post(0).empty()); + REQUIRE(aut.delta.state_post(1).empty()); + REQUIRE(aut.delta.state_post(2).empty()); + + CHECK(&aut.delta.state_post(4) == &aut.delta[4]); + } + + SECTION("Add new states over the limit") { + aut.add_state(1); + REQUIRE_NOTHROW(aut.initial.insert(0)); + REQUIRE_NOTHROW(aut.initial.insert(1)); + REQUIRE_NOTHROW(aut.delta.state_post(0)); + REQUIRE_NOTHROW(aut.delta.state_post(1)); + REQUIRE_NOTHROW(aut.delta.state_post(2)); + CHECK(aut.delta.state_post(0).empty()); + CHECK(aut.delta.state_post(1).empty()); + CHECK(aut.delta.state_post(2).empty()); + } + + SECTION("Add new states without specifying the number of states") { + CHECK_NOTHROW(aut.initial.insert(0)); + CHECK_NOTHROW(aut.delta.state_post(2)); + CHECK(aut.delta.state_post(0).empty()); + CHECK(aut.delta.state_post(2).empty()); + } + + SECTION("Add new initial without specifying the number of states with over +1 number") { + REQUIRE_NOTHROW(aut.initial.insert(25)); + CHECK_NOTHROW(aut.delta.state_post(25)); + CHECK_NOTHROW(aut.delta.state_post(26)); + CHECK(aut.delta.state_post(25).empty()); + CHECK(aut.delta.state_post(26).empty()); + } + + SECTION("Add multiple targets at once") { + CHECK_NOTHROW(aut.delta.add(0, 1, { 3, 4, 5, 6 })); + CHECK_NOTHROW(aut.delta.add(26, 1, StateSet{})); + CHECK_NOTHROW(aut.delta.add(42, 1, StateSet{ 43 })); + CHECK(aut.delta.num_of_transitions() == 5); + } +} + +TEST_CASE("mata::cntnfa::Delta::contains()") { + Cntnfa nfa; + CHECK(!nfa.delta.contains(0, 1, 0)); + CHECK(!nfa.delta.contains(Transition{ 0, 1, 0 })); + nfa.delta.add(0, 1, 0); + CHECK(nfa.delta.contains(0, 1, 0)); + CHECK(nfa.delta.contains(Transition{ 0, 1, 0 })); +} + +TEST_CASE("mata::cntnfa::Delta::remove()") { + Cntnfa nfa; + + SECTION("Simple remove") { + nfa.delta.add(0, 1, 0); + CHECK_NOTHROW(nfa.delta.remove(3, 5, 6)); + CHECK_NOTHROW(nfa.delta.remove(0, 1, 0)); + CHECK(nfa.delta.empty()); + nfa.delta.add(10, 1, 0); + CHECK_THROWS_AS(nfa.delta.remove(3, 5, 6), std::invalid_argument); + } +} + +TEST_CASE("mata::cntnfa::Delta::mutable_post()") { + Cntnfa nfa; + + SECTION("Default initialized") { + CHECK(nfa.delta.num_of_states() == 0); + CHECK(!nfa.delta.uses_state(0)); + CHECK(nfa.delta.mutable_state_post(0).empty()); + CHECK(nfa.delta.num_of_states() == 1); + CHECK(nfa.delta.uses_state(0)); + + CHECK(nfa.delta.mutable_state_post(9).empty()); + CHECK(nfa.delta.num_of_states() == 10); + CHECK(nfa.delta.uses_state(1)); + CHECK(nfa.delta.uses_state(2)); + CHECK(nfa.delta.uses_state(9)); + CHECK(!nfa.delta.uses_state(10)); + + CHECK(nfa.delta.mutable_state_post(9).empty()); + CHECK(nfa.delta.num_of_states() == 10); + CHECK(nfa.delta.uses_state(9)); + CHECK(!nfa.delta.uses_state(10)); + } +} + +TEST_CASE("mata::cntnfa::StatePost iteration over moves") { + Cntnfa nfa; + std::vector iterated_moves{}; + std::vector expected_moves{}; + StatePost state_post{}; + + SECTION("Simple NFA") { + nfa.initial.insert(0); + nfa.final.insert(3); + nfa.delta.add(0, 1, 1); + nfa.delta.add(0, 2, 1); + nfa.delta.add(0, 5, 1); + nfa.delta.add(1, 3, 2); + nfa.delta.add(2, 0, 1); + nfa.delta.add(2, 0, 3); + + state_post = nfa.delta.state_post(0); + expected_moves = std::vector{ { 1, 1 }, { 2, 1 }, { 5, 1 } }; + StatePost::Moves moves{ state_post.moves() }; + iterated_moves.clear(); + for (auto move_it{ moves.begin() }; move_it != moves.end(); ++move_it) { + iterated_moves.push_back(*move_it); + } + CHECK(iterated_moves == expected_moves); + + iterated_moves = { moves.begin(), moves.end() }; + CHECK(iterated_moves == expected_moves); + + iterated_moves.clear(); + for (const Move& move: state_post.moves()) { iterated_moves.push_back(move); } + CHECK(iterated_moves == expected_moves); + + StatePost::Moves epsilon_moves{ state_post.moves_epsilons() }; + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() }.empty()); + + state_post = nfa.delta.state_post(1); + moves = state_post.moves(); + StatePost::Moves moves_custom; + moves_custom = moves; + CHECK(std::vector{ moves.begin(), moves.end() } + == std::vector{ moves_custom.begin(), moves_custom.end() }); + moves_custom = state_post.moves(state_post.begin(), state_post.end()); + CHECK(std::vector{ moves.begin(), moves.end() } + == std::vector{ moves_custom.begin(), moves_custom.end() }); + iterated_moves.clear(); + for (auto move_it{ moves.begin() }; move_it != moves.end(); ++move_it) { + iterated_moves.push_back(*move_it); + } + expected_moves = std::vector{ { 3, 2 } }; + CHECK(iterated_moves == expected_moves); + iterated_moves = { moves.begin(), moves.end() }; + CHECK(iterated_moves == expected_moves); + iterated_moves.clear(); + for (const Move& move: state_post.moves()) { iterated_moves.push_back(move); } + CHECK(iterated_moves == expected_moves); + epsilon_moves = state_post.moves_epsilons(); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() }.empty()); + + state_post = nfa.delta.state_post(2); + moves = state_post.moves(); + iterated_moves.clear(); + for (auto move_it{ moves.begin() }; move_it != moves.end(); ++move_it) { + iterated_moves.push_back(*move_it); + } + expected_moves = std::vector{ { 0, 1 }, { 0, 3 } }; + CHECK(iterated_moves == expected_moves); + iterated_moves = { moves.begin(), moves.end() }; + CHECK(iterated_moves == expected_moves); + iterated_moves.clear(); + for (const Move& move: state_post.moves()) { iterated_moves.push_back(move); } + CHECK(iterated_moves == expected_moves); + epsilon_moves = state_post.moves_epsilons(); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() }.empty()); + + state_post = nfa.delta.state_post(3); + moves = state_post.moves(); + iterated_moves.clear(); + for (auto move_it{ moves.begin() }; move_it != moves.end(); ++move_it) { + iterated_moves.push_back(*move_it); + } + CHECK(iterated_moves.empty()); + CHECK(StatePost::Moves::const_iterator{ state_post } == moves.end()); + iterated_moves = { moves.begin(), moves.end() }; + CHECK(iterated_moves.empty()); + iterated_moves.clear(); + for (const Move& move: state_post.moves()) { iterated_moves.push_back(move); } + CHECK(iterated_moves.empty()); + epsilon_moves = state_post.moves_epsilons(); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() }.empty()); + + state_post = nfa.delta.state_post(4); + moves = state_post.moves(); + iterated_moves.clear(); + for (auto move_it{ moves.begin() }; move_it != moves.end(); ++move_it) { + iterated_moves.push_back(*move_it); + } + CHECK(iterated_moves.empty()); + iterated_moves = { moves.begin(), moves.end() }; + CHECK(iterated_moves.empty()); + iterated_moves.clear(); + for (const Move& move: state_post.moves()) { iterated_moves.push_back(move); } + CHECK(iterated_moves.empty()); + epsilon_moves = state_post.moves_epsilons(); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() }.empty()); + + nfa.delta.add(0, EPSILON, 2); + state_post = nfa.delta.state_post(0); + epsilon_moves = state_post.moves_epsilons(); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() } == std::vector{ { EPSILON, 2 } }); + nfa.delta.add(1, EPSILON, 3); + state_post = nfa.delta.state_post(1); + epsilon_moves = state_post.moves_epsilons(); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() } == std::vector{ { EPSILON, 3 } }); + nfa.delta.add(4, EPSILON, 4); + state_post = nfa.delta.state_post(4); + epsilon_moves = state_post.moves_epsilons(); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() } == std::vector{ { EPSILON, 4 } }); + + state_post = nfa.delta.state_post(0); + epsilon_moves = state_post.moves_epsilons(3); + iterated_moves.clear(); + for (const Move& move: epsilon_moves) { iterated_moves.push_back(move); } + CHECK(iterated_moves == std::vector{ { 5, 1 }, { EPSILON, 2 }}); + state_post = nfa.delta.state_post(1); + epsilon_moves = state_post.moves_epsilons(3); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() } == std::vector{ { 3, 2 }, { EPSILON, 3 } }); + + state_post = nfa.delta.state_post(2); + epsilon_moves = state_post.moves_epsilons(3); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() }.empty()); + state_post = nfa.delta.state_post(4); + epsilon_moves = state_post.moves_epsilons(3); + CHECK(std::vector{ epsilon_moves.begin(), epsilon_moves.end() } == std::vector{ { EPSILON, 4 } }); + + state_post = nfa.delta.state_post(0); + StatePost::Moves symbol_moves = state_post.moves_symbols(3); + iterated_moves.clear(); + for (const Move& move: symbol_moves) { iterated_moves.push_back(move); } + CHECK(iterated_moves == std::vector{ { 1, 1 }, { 2, 1 } }); + symbol_moves = state_post.moves_symbols(0); + iterated_moves.clear(); + for (const Move& move: symbol_moves) { iterated_moves.push_back(move); } + CHECK(iterated_moves.empty()); + + state_post = nfa.delta.state_post(1); + symbol_moves = state_post.moves_symbols(3); + CHECK(std::vector{ symbol_moves.begin(), symbol_moves.end() } == std::vector{ { 3, 2 } }); + state_post = nfa.delta.state_post(2); + symbol_moves = state_post.moves_symbols(3); + CHECK(std::vector{ symbol_moves.begin(), symbol_moves.end() } == std::vector{ { 0, 1 }, { 0 , 3 } }); + state_post = nfa.delta.state_post(4); + symbol_moves = state_post.moves_symbols(3); + CHECK(std::vector{ symbol_moves.begin(), symbol_moves.end() }.empty()); + + // Create custom moves iterator. + state_post = nfa.delta[0]; + moves = { state_post, state_post.cbegin(), state_post.cbegin() + 2 }; + iterated_moves = { moves.begin(), moves.end() }; + CHECK(iterated_moves == std::vector{ { 1, 1 }, { 2, 1 } }); + + state_post = nfa.delta[20]; + moves = { state_post, state_post.cbegin(), state_post.cend() }; + iterated_moves = { moves.begin(), moves.end() }; + CHECK(iterated_moves.empty()); + } +} + +TEST_CASE("mata::cntnfa::Delta iteration over transitions") { + Cntnfa nfa; + std::vector iterated_transitions{}; + std::vector expected_transitions{}; + + SECTION("empty automaton") { + Delta::Transitions transitions{ nfa.delta.transitions() }; + CHECK(transitions.begin() == transitions.end()); + Delta::Transitions::const_iterator transition_it{ nfa.delta }; + CHECK(transition_it == transitions.end()); + transition_it = { nfa.delta, 0 }; + CHECK(transition_it == transitions.end()); + } + + SECTION("Simple NFA") { + nfa.initial.insert(0); + nfa.final.insert(3); + nfa.delta.add(0, 1, 1); + nfa.delta.add(0, 2, 1); + nfa.delta.add(0, 5, 1); + nfa.delta.add(1, 3, 2); + nfa.delta.add(2, 0, 1); + nfa.delta.add(2, 0, 3); + + Delta::Transitions transitions{ nfa.delta.transitions() }; + iterated_transitions.clear(); + for (auto transitions_it{ transitions.begin() }; + transitions_it != transitions.end(); ++transitions_it) { + iterated_transitions.push_back(*transitions_it); + } + expected_transitions = std::vector{ + { 0, 1, 1 }, { 0, 2, 1 }, { 0, 5, 1 }, { 1, 3, 2 }, { 2, 0, 1 }, { 2, 0, 3 } + }; + CHECK(iterated_transitions == expected_transitions); + + iterated_transitions = { transitions.begin(), transitions.end() }; + CHECK(iterated_transitions == expected_transitions); + + iterated_transitions.clear(); + for (const Transition& transition: nfa.delta.transitions()) { iterated_transitions.push_back(transition); } + CHECK(iterated_transitions == expected_transitions); + + Delta::Transitions::const_iterator transitions_it{ nfa.delta.transitions().begin() }; + CHECK(*transitions_it == Transition{ 0, 1, 1 }); + transitions_it++; + CHECK(*transitions_it == Transition{ 0, 2, 1 }); + transitions_it++; + transitions_it++; + CHECK(*transitions_it == Transition{ 1, 3, 2 }); + + Delta::Transitions::const_iterator transitions_from_1_to_end_it{ nfa.delta, 1 }; + iterated_transitions.clear(); + while (transitions_from_1_to_end_it != nfa.delta.transitions().end()) { + iterated_transitions.push_back(*transitions_from_1_to_end_it); + transitions_from_1_to_end_it++; + } + expected_transitions = std::vector{ { 1, 3, 2 }, { 2, 0, 1 }, { 2, 0, 3 } }; + CHECK(iterated_transitions == expected_transitions); + } + + SECTION("Sparse automaton") { + const size_t state_num = 'r'+1; + nfa.delta.reserve(state_num); + + nfa.delta.add('q', 'a', 'r'); + nfa.delta.add('q', 'b', 'r'); + const Delta::Transitions transitions{ nfa.delta.transitions() }; + Delta::Transitions::const_iterator it{ transitions.begin() }; + Delta::Transitions::const_iterator jt{ transitions.begin() }; + CHECK(it == jt); + ++it; + CHECK(it != jt); + CHECK((it != transitions.begin() && it != transitions.end())); + CHECK(jt == transitions.begin()); + + ++jt; + CHECK(it == jt); + CHECK((jt != transitions.begin() && jt != transitions.end())); + + jt = transitions.end(); + CHECK(it != jt); + CHECK((jt != transitions.begin() && jt == transitions.end())); + + it = transitions.end(); + CHECK(it == jt); + CHECK((it != transitions.begin() && it == transitions.end())); + } +} + +TEST_CASE("mata::cntnfa::Delta::operator=()") { + Cntnfa nfa{}; + nfa.initial.insert(0); + nfa.final.insert(1); + nfa.delta.add(0, 'a', 1); + + Cntnfa copied_nfa{ nfa }; + nfa.delta.add(1, 'b', 0); + CHECK(nfa.delta.num_of_transitions() == 2); + CHECK(copied_nfa.delta.num_of_transitions() == 1); +} + +TEST_CASE("mata::cntnfa::StatePost::Moves") { + Cntnfa nfa{}; + nfa.initial.insert(0); + nfa.final.insert(5); + nfa.delta.add(0, 'a', 1); + nfa.delta.add(1, 'b', 2); + nfa.delta.add(1, 'c', 2); + nfa.delta.add(1, 'd', 2); + nfa.delta.add(2, 'e', 3); + nfa.delta.add(3, 'e', 4); + nfa.delta.add(4, 'f', 5); + // TODO: rewrite in a check of moves. + StatePost::Moves moves_from_source{ nfa.delta[0].moves() }; + + CHECK(std::vector{ moves_from_source.begin(), moves_from_source.end() } == std::vector{ { 'a', 1 }}); + moves_from_source = nfa.delta[1].moves(); + CHECK(std::vector{ moves_from_source.begin(), moves_from_source.end() } == + std::vector{ { 'b', 2 }, { 'c', 2 }, { 'd', 2 } }); + StatePost::Moves::const_iterator move_incremented_it{ moves_from_source.begin() }; + ++move_incremented_it; + CHECK(*move_incremented_it == Move{ 'c', 2 }); + CHECK(*StatePost::Moves::const_iterator{ nfa.delta.state_post(1) } == Move{ 'b', 2 }); + CHECK(move_incremented_it != moves_from_source.begin()); + CHECK(move_incremented_it == ++moves_from_source.begin()); + StatePost::Moves moves_from_source_copy_constructed{ nfa.delta[12].moves() }; + CHECK( + std::vector{ moves_from_source_copy_constructed.begin(), moves_from_source_copy_constructed.end() } + .empty() + ); +} + +TEST_CASE("mata::cntnfa::Delta::operator==()") { + Delta delta{}; + Delta delta2{}; + CHECK(delta == delta2); + delta.add(0, 0, 0); + CHECK(delta != delta2); + delta2.add(0, 0, 0); + CHECK(delta == delta2); + delta.add(0, 0, 1); + delta2.add(0, 0, 2); + CHECK(delta != delta2); + delta2.add(0, 0, 1); + CHECK(delta != delta2); + delta.add(0, 0, 2); + CHECK(delta == delta2); + delta2.add(0, 0, 3); + CHECK(delta != delta2); + delta.add(0, 0, 3); + CHECK(delta == delta2); +} + +TEST_CASE("mata::cntnfa::Delta::add_symbols_to()") { + mata::OnTheFlyAlphabet empty_alphabet{}; + mata::OnTheFlyAlphabet alphabet{}; + Delta delta{}; + delta.add_symbols_to(alphabet); + CHECK(alphabet.get_symbol_map().empty()); + delta.add(0, 0, 0); + delta.add_symbols_to(alphabet); + CHECK(alphabet.get_symbol_map().size() == 1); + delta.add(0, 0, 0); + delta.add_symbols_to(alphabet); + CHECK(alphabet.get_symbol_map().size() == 1); + delta.add(0, 1, 0); + delta.add_symbols_to(alphabet); + CHECK(alphabet.get_symbol_map().size() == 2); + delta.add(0, 2, 0); + delta.add(0, 3, 0); + delta.add_symbols_to(alphabet); + CHECK(alphabet.get_symbol_map().size() == 4); + CHECK(alphabet.get_symbol_map() == std::unordered_map{ + { "0", 0 }, { "1", 1 }, { "2", 2 }, { "3", 3 } + }); +} + +TEST_CASE("Cntnfa: Transition comparison") { + Transition tr1 {1, 2, 3}; + Transition tr2 {1, 3, 1}; + Transition tr3 {1, 2, 5}; + Transition tr4 {1, 2, 1}; + Transition tr5 {1, 2, 1}; + + CHECK(tr1 < tr2); + CHECK(tr2 >= tr3); + CHECK(tr3 >= tr1); + CHECK(tr4 < tr3); + CHECK(tr5 <= tr4); + CHECK(tr5 == tr4); +} diff --git a/tests/cntnfa/utils.hh b/tests/cntnfa/utils.hh new file mode 100644 index 000000000..8ee2cf007 --- /dev/null +++ b/tests/cntnfa/utils.hh @@ -0,0 +1,102 @@ +#ifndef UTILS_HH +#define UTILS_HH + +// Automaton A +#define FILL_WITH_AUT_A(x) \ + x.initial = {1, 3}; \ + x.final = {5}; \ + x.delta.add(1, 'a', 3); \ + x.delta.add(1, 'a', 10); \ + x.delta.add(1, 'b', 7); \ + x.delta.add(3, 'a', 7); \ + x.delta.add(3, 'b', 9); \ + x.delta.add(9, 'a', 9); \ + x.delta.add(7, 'b', 1); \ + x.delta.add(7, 'a', 3); \ + x.delta.add(7, 'c', 3); \ + x.delta.add(10, 'a', 7); \ + x.delta.add(10, 'b', 7); \ + x.delta.add(10, 'c', 7); \ + x.delta.add(7, 'a', 5); \ + x.delta.add(5, 'a', 5); \ + x.delta.add(5, 'c', 9); \ + +// Automaton B +#define FILL_WITH_AUT_B(x) \ + x.initial = {4}; \ + x.final = {2, 12}; \ + x.delta.add(4, 'c', 8); \ + x.delta.add(4, 'a', 8); \ + x.delta.add(8, 'b', 4); \ + x.delta.add(4, 'a', 6); \ + x.delta.add(4, 'b', 6); \ + x.delta.add(6, 'a', 2); \ + x.delta.add(2, 'b', 2); \ + x.delta.add(2, 'a', 0); \ + x.delta.add(0, 'a', 2); \ + x.delta.add(2, 'c', 12); \ + x.delta.add(12, 'a', 14); \ + x.delta.add(14, 'b', 12); \ + +// Automaton C +// the same as B, but with small symbols +#define FILL_WITH_AUT_C(x) \ + x.initial = {4}; \ + x.final = {2, 12}; \ + x.delta.add(4, 3, 8); \ + x.delta.add(4, 1, 8); \ + x.delta.add(8, 2, 4); \ + x.delta.add(4, 1, 6); \ + x.delta.add(4, 2, 6); \ + x.delta.add(6, 1, 2); \ + x.delta.add(2, 2, 2); \ + x.delta.add(2, 1, 0); \ + x.delta.add(0, 1, 2); \ + x.delta.add(2, 3, 12); \ + x.delta.add(12, 1, 14); \ + x.delta.add(14, 2, 12); \ + +// Automaton D // shomewhat larger +#define FILL_WITH_AUT_D(x) \ + x.initial = {0}; \ + x.final = {3}; \ + x.delta.add(0, 46, 0); \ + x.delta.add(0, 47, 0); \ + x.delta.add(0, 58, 0); \ + x.delta.add(0, 58, 1); \ + x.delta.add(0, 64, 1); \ + x.delta.add(0, 64, 1); \ + x.delta.add(0, 82, 2); \ + x.delta.add(0, 92, 2); \ + x.delta.add(0, 98, 2); \ + x.delta.add(0, 100, 1);\ + x.delta.add(0, 103, 0);\ + x.delta.add(0, 109, 0);\ + x.delta.add(0, 110, 1);\ + x.delta.add(0, 111, 2);\ + x.delta.add(0, 114, 0);\ + x.delta.add(1, 47, 2); \ + x.delta.add(2, 47, 3); \ + x.delta.add(3, 46, 2); \ + x.delta.add(3, 47, 0); \ + x.delta.add(3, 58, 2); \ + x.delta.add(3, 64, 3); \ + x.delta.add(3, 82, 2); \ + x.delta.add(3, 92, 0); \ + x.delta.add(3, 98, 2); \ + x.delta.add(3, 100, 2);\ + x.delta.add(3, 103, 3);\ + x.delta.add(3, 109, 2);\ + x.delta.add(3, 110, 3);\ + x.delta.add(3, 111, 2);\ + x.delta.add(3, 114, 3);\ + +// Automaton E +#define FILL_WITH_AUT_E(x) \ + x.initial = {1, 3}; \ + x.final = {4}; \ + x.delta.add(1, 'b', 2); \ + x.delta.add(2, 'a', 4); \ + x.delta.add(1, 'a', 3); \ + +#endif // UTILS_HH