diff --git a/.gitignore b/.gitignore
index 6e50ce45..4d984534 100644
--- a/.gitignore
+++ b/.gitignore
@@ -46,10 +46,6 @@ sqlite3
 src/config.h
 src/config.h.in
 src/hs_version.h
-src/fdr/fdr_autogen.c
-src/fdr/fdr_autogen_compiler.cpp
-src/fdr/teddy_autogen.c
-src/fdr/teddy_autogen_compiler.cpp
 src/parser/Parser.cpp
 
 # Generated PCRE files
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c137017a..19a37b8e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,40 @@
 
 This is a list of notable changes to Hyperscan, in reverse chronological order.
 
+## [4.2.0] 2016-05-31
+- Introduce an interpreter for many complex actions to replace the use of
+  internal reports within the core of Hyperscan (the "Rose" engine). This
+  improves scanning performance and reduces database size for many pattern
+  sets.
+- Many enhancements to the acceleration framework used by NFA and DFA engines,
+  including more flexible multibyte implementations and more AVX2 support. This
+  improves scanning performance for many pattern sets.
+- Improved prefiltering support for complex patterns containing very large
+  bounded repeats (`R{M,N}` with large `N`).
+- Improve scanning performance of pattern sets with a very large number of
+  EOD-anchored patterns.
+- Improve scanning performance of large pattern sets that use the
+  `HS_FLAG_SINGLEMATCH` flag.
+- Improve scanning performance of pattern sets that contain a single literal by
+  improving the "Noodle" literal matcher.
+- Small reductions in total stream state for many pattern sets.
+- Improve runtime detection of AVX2 support.
+- Disable -Werror for release builds, in order to behave better for packagers
+  and users with different compiler combinations than those that we test.
+- Improve support for building on Windows with MSVC 2015 (github issue #14).
+  Support for Hyperscan on Windows is still experimental.
+- Small updates to fix warnings identified by Coverity.
+- Remove Python codegen for the "FDR" and "Teddy" literal matchers. These are
+  now implemented directly in C code.
+- Remove the specialist "Sidecar" engine in favour of using our more general
+  repeat engines.
+- New API function: add the `hs_expression_ext_info()` function. This is a
+  variant of `hs_expression_info()` that can accept patterns with extended
+  parameters.
+- New API error value: add the `HS_SCRATCH_IN_USE` error, which is returned
+  when Hyperscan detects that a scratch region is already in use on entry to an
+  API function.
+
 ## [4.1.0] 2015-12-18
 - Update version of PCRE used by testing tools as a syntax and semantic
   reference to PCRE 8.38.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b4d81754..c824b6a6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required (VERSION 2.8.11)
 project (Hyperscan C CXX)
 
 set (HS_MAJOR_VERSION 4)
-set (HS_MINOR_VERSION 1)
+set (HS_MINOR_VERSION 2)
 set (HS_PATCH_VERSION 0)
 set (HS_VERSION ${HS_MAJOR_VERSION}.${HS_MINOR_VERSION}.${HS_PATCH_VERSION})
 
@@ -75,7 +75,7 @@ if(NOT Boost_FOUND)
     set(BOOST_INCLUDEDIR "${PROJECT_SOURCE_DIR}/include")
     find_package(Boost ${BOOST_MINVERSION})
     if(NOT Boost_FOUND)
-        message(FATAL_ERROR "Boost ${BOOST_MINVERSION} or later not found. Either install system pacakges if available, extract Boost headers to ${CMAKE_SOURCE_DIR}/include, or set the CMake BOOST_ROOT variable.")
+        message(FATAL_ERROR "Boost ${BOOST_MINVERSION} or later not found. Either install system packages if available, extract Boost headers to ${CMAKE_SOURCE_DIR}/include, or set the CMake BOOST_ROOT variable.")
     endif()
 endif()
 
@@ -115,7 +115,9 @@ if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS)
 endif()
 
 #for config
-set(HS_OPTIMIZE OPTIMISE)
+if (OPTIMISE)
+    set(HS_OPTIMIZE ON)
+endif()
 
 CMAKE_DEPENDENT_OPTION(DUMP_SUPPORT "Dump code support; normally on, except in release builds" ON "NOT RELEASE_BUILD" OFF)
 
@@ -171,8 +173,14 @@ else()
     endif()
 
     # set compiler flags - more are tested and added later
-    set(EXTRA_C_FLAGS "-std=c99 -Wall -Wextra -Wshadow -Wcast-qual -Werror")
-    set(EXTRA_CXX_FLAGS "-std=c++11 -Wall -Wextra -Werror -Wno-shadow -Wswitch -Wreturn-type -Wcast-qual -Wno-deprecated -Wnon-virtual-dtor")
+    set(EXTRA_C_FLAGS "-std=c99 -Wall -Wextra -Wshadow -Wcast-qual")
+    set(EXTRA_CXX_FLAGS "-std=c++11 -Wall -Wextra -Wno-shadow -Wswitch -Wreturn-type -Wcast-qual -Wno-deprecated -Wnon-virtual-dtor")
+    if (NOT RELEASE_BUILD)
+        # -Werror is most useful during development, don't potentially break
+        # release builds
+        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Werror")
+        set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -Werror")
+    endif()
 
     if (NOT CMAKE_C_FLAGS MATCHES .*march.*)
         message(STATUS "Building for current host CPU")
@@ -229,6 +237,9 @@ if (RELEASE_BUILD)
     endif()
 endif()
 
+# ensure we are building for the right target arch
+include (${CMAKE_MODULE_PATH}/arch.cmake)
+
 # testing a builtin takes a little more work
 CHECK_C_SOURCE_COMPILES("void *aa_test(void *x) { return __builtin_assume_aligned(x, 16);}\nint main(void) { return 0; }" HAVE_CC_BUILTIN_ASSUME_ALIGNED)
 CHECK_CXX_SOURCE_COMPILES("void *aa_test(void *x) { return __builtin_assume_aligned(x, 16);}\nint main(void) { return 0; }" HAVE_CXX_BUILTIN_ASSUME_ALIGNED)
@@ -332,7 +343,7 @@ endif()
 add_subdirectory(util)
 add_subdirectory(unit)
 add_subdirectory(doc/dev-reference)
-if (EXISTS ${CMAKE_SOURCE_DIR}/tools)
+if (EXISTS ${CMAKE_SOURCE_DIR}/tools/CMakeLists.txt)
     add_subdirectory(tools)
 endif()
 
@@ -340,8 +351,15 @@ endif()
 configure_file(${CMAKE_MODULE_PATH}/config.h.in ${PROJECT_BINARY_DIR}/config.h)
 configure_file(src/hs_version.h.in ${PROJECT_BINARY_DIR}/hs_version.h)
 
-if (PKG_CONFIG_FOUND)
-    # we really only need to do this if we have pkg-config
+if (NOT WIN32)
+    # expand out library names for pkgconfig static link info
+    foreach (LIB ${CMAKE_CXX_IMPLICIT_LINK_LIBRARIES})
+        # this is fragile, but protects us from toolchain specific files
+        if (NOT EXISTS ${LIB})
+            set(PRIVATE_LIBS "${PRIVATE_LIBS} -l${LIB}")
+        endif()
+    endforeach()
+
     configure_file(libhs.pc.in libhs.pc @ONLY) # only replace @ quoted vars
     install(FILES ${CMAKE_BINARY_DIR}/libhs.pc
             DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/pkgconfig")
@@ -352,11 +370,6 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
 
 
-# include the autogen targets
-add_subdirectory(src/fdr)
-
-include_directories(${PROJECT_BINARY_DIR}/src/fdr)
-
 if(NOT WIN32)
 set(RAGEL_C_FLAGS "-Wno-unused")
 endif()
@@ -376,14 +389,13 @@ SET(hs_HEADERS
 )
 install(FILES ${hs_HEADERS} DESTINATION include/hs)
 
-set(fdr_autogen_targets autogen_runtime autogen_teddy_runtime)
-
 set (hs_exec_SRCS
     ${hs_HEADERS}
     src/hs_version.h
     src/ue2common.h
     src/alloc.c
     src/allocator.h
+    src/report.h
     src/runtime.c
     src/fdr/fdr.c
     src/fdr/fdr.h
@@ -394,7 +406,9 @@ set (hs_exec_SRCS
     src/fdr/flood_runtime.h
     src/fdr/fdr_loadval.h
     src/fdr/teddy.c
+    src/fdr/teddy.h
     src/fdr/teddy_internal.h
+    src/fdr/teddy_runtime_common.h
     src/hwlm/hwlm.c
     src/hwlm/hwlm.h
     src/hwlm/hwlm_internal.h
@@ -437,6 +451,25 @@ set (hs_exec_SRCS
     src/nfa/mpv.h
     src/nfa/mpv.c
     src/nfa/mpv_internal.h
+    src/nfa/multiaccel_common.h
+    src/nfa/multiaccel_doubleshift.h
+    src/nfa/multiaccel_doubleshiftgrab.h
+    src/nfa/multiaccel_long.h
+    src/nfa/multiaccel_longgrab.h
+    src/nfa/multiaccel_shift.h
+    src/nfa/multiaccel_shiftgrab.h
+    src/nfa/multishufti.c
+    src/nfa/multishufti_avx2.h
+    src/nfa/multishufti_sse.h
+    src/nfa/multishufti.h
+    src/nfa/multitruffle.c
+    src/nfa/multitruffle_avx2.h
+    src/nfa/multitruffle_sse.h
+    src/nfa/multitruffle.h
+    src/nfa/multivermicelli.c
+    src/nfa/multivermicelli.h
+    src/nfa/multivermicelli_sse.h
+    src/nfa/multivermicelli_avx2.h
     src/nfa/nfa_api.h
     src/nfa/nfa_api_dispatch.c
     src/nfa/nfa_internal.h
@@ -444,20 +477,17 @@ set (hs_exec_SRCS
     src/nfa/repeat.c
     src/nfa/repeat.h
     src/nfa/repeat_internal.h
+    src/nfa/shufti_common.h
     src/nfa/shufti.c
     src/nfa/shufti.h
+    src/nfa/truffle_common.h
     src/nfa/truffle.c
     src/nfa/truffle.h
     src/nfa/vermicelli.h
     src/nfa/vermicelli_run.h
     src/nfa/vermicelli_sse.h
-    src/sidecar/sidecar.c
-    src/sidecar/sidecar.h
-    src/sidecar/sidecar_generic.h
-    src/sidecar/sidecar_internal.h
-    src/sidecar/sidecar_shufti.c
-    src/sidecar/sidecar_shufti.h
     src/som/som.h
+    src/som/som_operation.h
     src/som/som_runtime.h
     src/som/som_runtime.c
     src/som/som_stream.c
@@ -473,10 +503,11 @@ set (hs_exec_SRCS
     src/rose/match.h
     src/rose/match.c
     src/rose/miracle.h
+    src/rose/program_runtime.h
     src/rose/runtime.h
-    src/rose/rose_sidecar_runtime.h
     src/rose/rose.h
     src/rose/rose_internal.h
+    src/rose/rose_program.h
     src/rose/rose_types.h
     src/rose/rose_common.h
     src/util/bitutils.h
@@ -484,7 +515,6 @@ set (hs_exec_SRCS
     src/util/fatbit.h
     src/util/fatbit.c
     src/util/join.h
-    src/util/masked_move.c
     src/util/masked_move.h
     src/util/multibit.h
     src/util/multibit_internal.h
@@ -498,6 +528,7 @@ set (hs_exec_SRCS
     src/util/shuffle_ssse3.h
     src/util/simd_utils.h
     src/util/simd_utils_ssse3.h
+    src/util/simd_utils_ssse3.c
     src/util/state_compress.h
     src/util/state_compress.c
     src/util/unaligned.h
@@ -510,6 +541,14 @@ set (hs_exec_SRCS
     src/database.h
 )
 
+if (HAVE_AVX2)
+    set (hs_exec_SRCS
+        ${hs_exec_SRCS}
+        src/fdr/teddy_avx2.c
+        src/util/masked_move.c
+        )
+endif ()
+
 
 SET (hs_SRCS
     ${hs_HEADERS}
@@ -574,6 +613,8 @@ SET (hs_SRCS
     src/nfa/mcclellan_internal.h
     src/nfa/mcclellancompile.cpp
     src/nfa/mcclellancompile.h
+    src/nfa/mcclellancompile_accel.cpp
+    src/nfa/mcclellancompile_accel.h
     src/nfa/mcclellancompile_util.cpp
     src/nfa/mcclellancompile_util.h
     src/nfa/limex_compile.cpp
@@ -583,6 +624,8 @@ SET (hs_SRCS
     src/nfa/mpv_internal.h
     src/nfa/mpvcompile.cpp
     src/nfa/mpvcompile.h
+    src/nfa/multiaccel_compilehelper.cpp
+    src/nfa/multiaccel_compilehelper.h
     src/nfa/nfa_api.h
     src/nfa/nfa_api_queue.h
     src/nfa/nfa_api_util.h
@@ -762,8 +805,6 @@ SET (hs_SRCS
     src/parser/unsupported.h
     src/parser/utf8_validate.h
     src/parser/utf8_validate.cpp
-    src/sidecar/sidecar_compile.cpp
-    src/sidecar/sidecar_compile.h
     src/smallwrite/smallwrite_build.cpp
     src/smallwrite/smallwrite_build.h
     src/smallwrite/smallwrite_internal.h
@@ -771,6 +812,7 @@ SET (hs_SRCS
     src/som/slot_manager.h
     src/som/slot_manager_internal.h
     src/som/som.h
+    src/som/som_operation.h
     src/rose/rose_build.h
     src/rose/rose_build_add.cpp
     src/rose/rose_build_add_internal.h
@@ -778,6 +820,8 @@ SET (hs_SRCS
     src/rose/rose_build_anchored.cpp
     src/rose/rose_build_anchored.h
     src/rose/rose_build_bytecode.cpp
+    src/rose/rose_build_castle.h
+    src/rose/rose_build_castle.cpp
     src/rose/rose_build_compile.cpp
     src/rose/rose_build_convert.cpp
     src/rose/rose_build_convert.h
@@ -786,6 +830,8 @@ SET (hs_SRCS
     src/rose/rose_build_infix.h
     src/rose/rose_build_lookaround.cpp
     src/rose/rose_build_lookaround.h
+    src/rose/rose_build_matchers.cpp
+    src/rose/rose_build_matchers.h
     src/rose/rose_build_merge.cpp
     src/rose/rose_build_merge.h
     src/rose/rose_build_misc.cpp
@@ -799,6 +845,7 @@ SET (hs_SRCS
     src/rose/rose_in_graph.h
     src/rose/rose_in_util.cpp
     src/rose/rose_in_util.h
+    src/util/accel_scheme.h
     src/util/alloc.cpp
     src/util/alloc.h
     src/util/bitfield.h
@@ -820,7 +867,6 @@ SET (hs_SRCS
     src/util/dump_mask.cpp
     src/util/dump_mask.h
     src/util/graph.h
-    src/util/internal_report.h
     src/util/multibit_build.cpp
     src/util/multibit_build.h
     src/util/order_check.h
@@ -828,7 +874,6 @@ SET (hs_SRCS
     src/util/partitioned_set.h
     src/util/popcount.h
     src/util/queue_index_factory.h
-    src/util/report.cpp
     src/util/report.h
     src/util/report_manager.cpp
     src/util/report_manager.h
@@ -874,8 +919,6 @@ set(hs_dump_SRCS
     src/parser/dump.cpp
     src/parser/dump.h
     src/parser/position_dump.h
-    src/sidecar/sidecar_dump.cpp
-    src/sidecar/sidecar_dump.h
     src/smallwrite/smallwrite_dump.cpp
     src/smallwrite/smallwrite_dump.h
     src/som/slot_manager_dump.cpp
@@ -901,11 +944,9 @@ set (LIB_VERSION ${HS_VERSION})
 set (LIB_SOVERSION ${HS_MAJOR_VERSION}.${HS_MINOR_VERSION})
 
 add_library(hs_exec OBJECT ${hs_exec_SRCS})
-add_dependencies(hs_exec ${fdr_autogen_targets})
 
 if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS)
 add_library(hs_exec_shared OBJECT ${hs_exec_SRCS})
-add_dependencies(hs_exec_shared ${fdr_autogen_targets})
 set_target_properties(hs_exec_shared PROPERTIES
     POSITION_INDEPENDENT_CODE TRUE)
 endif()
@@ -929,14 +970,16 @@ if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS)
         OUTPUT_NAME hs_runtime
         MACOSX_RPATH ON
         LINKER_LANGUAGE C)
-    install(TARGETS hs_runtime_shared DESTINATION lib)
+    install(TARGETS hs_runtime_shared
+        RUNTIME DESTINATION bin
+        ARCHIVE DESTINATION lib
+        LIBRARY DESTINATION lib)
 endif()
 
 # we want the static lib for testing
 add_library(hs STATIC ${hs_SRCS} $<TARGET_OBJECTS:hs_exec>)
 
 add_dependencies(hs ragel_Parser)
-add_dependencies(hs autogen_compiler autogen_teddy_compiler)
 
 if (NOT BUILD_SHARED_LIBS)
 install(TARGETS hs DESTINATION lib)
@@ -945,13 +988,15 @@ endif()
 if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS)
     add_library(hs_shared SHARED ${hs_SRCS} $<TARGET_OBJECTS:hs_exec_shared>)
     add_dependencies(hs_shared ragel_Parser)
-    add_dependencies(hs_shared autogen_compiler autogen_teddy_compiler)
     set_target_properties(hs_shared PROPERTIES
         OUTPUT_NAME hs
         VERSION ${LIB_VERSION}
         SOVERSION ${LIB_SOVERSION}
         MACOSX_RPATH ON)
-install(TARGETS hs_shared DESTINATION lib)
+install(TARGETS hs_shared
+    RUNTIME DESTINATION bin
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib)
 endif()
 
 if(NOT WIN32)
diff --git a/cmake/arch.cmake b/cmake/arch.cmake
new file mode 100644
index 00000000..c00401dd
--- /dev/null
+++ b/cmake/arch.cmake
@@ -0,0 +1,42 @@
+# detect architecture features
+#
+# must be called after determining where compiler intrinsics are defined
+
+if (HAVE_C_X86INTRIN_H)
+    set (INTRIN_INC_H "x86intrin.h")
+elseif (HAVE_C_INTRIN_H)
+    set (INTRIN_INC_H "intrin.h")
+else ()
+    message (FATAL_ERROR "No intrinsics header found")
+endif ()
+
+
+set (CMAKE_REQUIRED_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}")
+# ensure we have the minimum of SSSE3 - call a SSSE3 intrinsic
+CHECK_C_SOURCE_COMPILES("#include <${INTRIN_INC_H}>
+int main() {
+    __m128i a = _mm_set1_epi8(1);
+    (void)_mm_shuffle_epi8(a, a);
+}" HAVE_SSSE3)
+
+if (NOT HAVE_SSSE3)
+    message(FATAL_ERROR "A minimum of SSSE3 compiler support is required")
+endif ()
+
+# now look for AVX2
+CHECK_C_SOURCE_COMPILES("#include <${INTRIN_INC_H}>
+#if !defined(__AVX2__)
+#error no avx2
+#endif
+
+int main(){
+    __m256i z = _mm256_setzero_si256();
+    (void)_mm256_xor_si256(z, z);
+}" HAVE_AVX2)
+
+if (NOT HAVE_AVX2)
+    message(STATUS "Building without AVX2 support")
+endif ()
+
+unset (CMAKE_REQUIRED_FLAGS)
+unset (INTRIN_INC_H)
diff --git a/cmake/config.h.in b/cmake/config.h.in
index 63e0afc2..75c27b3e 100644
--- a/cmake/config.h.in
+++ b/cmake/config.h.in
@@ -15,9 +15,6 @@
 /* internal build, switch on dump support. */
 #cmakedefine DUMP_SUPPORT
 
-/* Build tools with threading support */
-#cmakedefine ENABLE_TOOLS_THREADS
-
 /* Define to 1 if `backtrace' works. */
 #cmakedefine HAVE_BACKTRACE
 
@@ -39,10 +36,6 @@
 /* C compiler has intrin.h */
 #cmakedefine HAVE_C_INTRIN_H
 
-/* Define to 1 if you have the declaration of `pthread_barrier_init', and to 0
-   if you don't. */
-#cmakedefine HAVE_DECL_PTHREAD_BARRIER_INIT
-
 /* Define to 1 if you have the declaration of `pthread_setaffinity_np', and to
    0 if you don't. */
 #cmakedefine HAVE_DECL_PTHREAD_SETAFFINITY_NP
@@ -59,9 +52,6 @@
 /* Define to 1 if `posix_memalign' works. */
 #cmakedefine HAVE_POSIX_MEMALIGN
 
-/* Define to 1 if you have the <pthread.h> header file. */
-#cmakedefine HAVE_PTHREAD_H
-
 /* Define to 1 if you have the `setrlimit' function. */
 #cmakedefine HAVE_SETRLIMIT
 
diff --git a/doc/dev-reference/compilation.rst b/doc/dev-reference/compilation.rst
index f3723dc9..8f44c15c 100644
--- a/doc/dev-reference/compilation.rst
+++ b/doc/dev-reference/compilation.rst
@@ -119,12 +119,21 @@ The following regex constructs are supported by Hyperscan:
 * The anchors :regexp:`^`, :regexp:`$`, :regexp:`\\A`, :regexp:`\\Z` and
   :regexp:`\\z`.
 
-* Option modifiers for:
+* Option modifiers:
 
-    * Case-sensitivity: :regexp:`(?i)` and :regexp:`(?-i)`
-    * Multi-line: :regexp:`(?m)` and :regexp:`(?-m)`
-    * Dot-all: :regexp:`(?s)` and :regexp:`(?-s)`
-    * Extended syntax: :regexp:`(?s)` and :regexp:`(?-s)`
+  These allow behaviour to be switched on (with :regexp:`(?<option>)`) and off
+  (with :regexp:`(?-<option>)`) for a sub-pattern. The supported options are:
+
+    * :regexp:`i`: Case-insensitive matching, as per
+      :c:member:`HS_FLAG_CASELESS`.
+    * :regexp:`m`: Multi-line matching, as per :c:member:`HS_FLAG_MULTILINE`.
+    * :regexp:`s`: Interpret ``.`` as "any character", as per
+      :c:member:`HS_FLAG_DOTALL`.
+    * :regexp:`x`: Extended syntax, which will ignore most whitespace in the
+      pattern for compatibility with libpcre's ``PCRE_EXTENDED`` option.
+
+  For example, the expression :regexp:`foo(?i)bar(?-i)baz` will switch on
+  case-insensitive matching *only* for the ``bar`` portion of the match.
 
 * The :regexp:`\\b` and :regexp:`\\B` zero-width assertions (word boundary and
   'not word boundary', respectively).
diff --git a/doc/dev-reference/conf.py.in b/doc/dev-reference/conf.py.in
index 169568f4..9f089883 100644
--- a/doc/dev-reference/conf.py.in
+++ b/doc/dev-reference/conf.py.in
@@ -44,7 +44,7 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'Hyperscan'
-copyright = u'2015, Intel Corporation'
+copyright = u'2015-2016, Intel Corporation'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
diff --git a/doc/dev-reference/copyright.rst b/doc/dev-reference/copyright.rst
index 88be1adc..737b160f 100644
--- a/doc/dev-reference/copyright.rst
+++ b/doc/dev-reference/copyright.rst
@@ -30,4 +30,4 @@ and/or other countries.
 
 \*Other names and brands may be claimed as the property of others.
 
-Copyright |copy| 2015, Intel Corporation. All rights reserved.
+Copyright |copy| 2015-2016, Intel Corporation. All rights reserved.
diff --git a/doc/dev-reference/index.rst b/doc/dev-reference/index.rst
index ddc523f0..df4f8916 100644
--- a/doc/dev-reference/index.rst
+++ b/doc/dev-reference/index.rst
@@ -15,6 +15,7 @@ Hyperscan |version| Developer's Reference Guide
    getting_started
    compilation
    runtime
+   serialization
    performance
    api_constants
    api_files
diff --git a/doc/dev-reference/runtime.rst b/doc/dev-reference/runtime.rst
index 0f3fc5fa..665395a8 100644
--- a/doc/dev-reference/runtime.rst
+++ b/doc/dev-reference/runtime.rst
@@ -124,13 +124,19 @@ databases, only a single scratch region is necessary: in this case, calling
 will ensure that the scratch space is large enough to support scanning against
 any of the given databases.
 
-Importantly, only one such space is required per thread and can (and indeed
-should) be allocated before data scanning is to commence. In a scenario where a
-set of expressions are compiled by a single "master" thread and data will be
-scanned by multiple "worker" threads, the convenience function
-:c:func:`hs_clone_scratch` allows multiple copies of an existing scratch space
-to be made for each thread (rather than forcing the caller to pass all the
-compiled databases through :c:func:`hs_alloc_scratch` multiple times).
+While the Hyperscan library is re-entrant, the use of scratch spaces is not.
+For example, if by design it is deemed necessary to run recursive or nested
+scanning (say, from the match callback function), then an additional scratch
+space is required for that context.
+
+In the absence of recursive scanning, only one such space is required per thread
+and can (and indeed should) be allocated before data scanning is to commence.
+
+In a scenario where a set of expressions are compiled by a single "master"
+thread and data will be scanned by multiple "worker" threads, the convenience
+function :c:func:`hs_clone_scratch` allows multiple copies of an existing
+scratch space to be made for each thread (rather than forcing the caller to pass
+all the compiled databases through :c:func:`hs_alloc_scratch` multiple times).
 
 For example:
 
@@ -163,14 +169,6 @@ For example:
     /* Now two threads can both scan against database db,
        each with its own scratch space. */
 
-While the Hyperscan library is re-entrant, the use of scratch spaces is not.
-For example, if by design it is deemed necessary to run recursive or nested
-scanning (say, from the match callback function), then an additional scratch
-space is required for that context.
-
-The easiest way to achieve this is to build up a single scratch space as a
-prototype, then clone it for each context:
-
 *****************
 Custom Allocators
 *****************
diff --git a/doc/dev-reference/serialization.rst b/doc/dev-reference/serialization.rst
new file mode 100644
index 00000000..4f884c75
--- /dev/null
+++ b/doc/dev-reference/serialization.rst
@@ -0,0 +1,67 @@
+.. _serialization:
+
+#############
+Serialization
+#############
+
+For some applications, compiling Hyperscan pattern databases immediately prior
+to use is not an appropriate design. Some users may wish to:
+
+* Compile pattern databases on a different host;
+
+* Persist compiled databases to storage and only re-compile pattern databases
+  when the patterns change;
+
+* Control the region of memory in which the compiled database is located.
+
+Hyperscan pattern databases are not completely flat in memory: they contain
+pointers and have specific alignment requirements. Therefore, they cannot be
+copied (or otherwise relocated) directly. To enable these use cases, Hyperscan
+provides functionality for serializing and deserializing compiled pattern
+databases.
+
+The API provides the following functions:
+
+#. :c:func:`hs_serialize_database`: serializes a pattern database into a
+   flat relocatable buffer of bytes.
+
+#. :c:func:`hs_deserialize_database`: reconstructs a newly allocated pattern
+   database from the output of :c:func:`hs_serialize_database`.
+
+#. :c:func:`hs_deserialize_database_at`: reconstructs a pattern
+   database at a given memory location from the output of
+   :c:func:`hs_serialize_database`.
+
+#. :c:func:`hs_serialized_database_size`: given a serialized pattern database,
+   returns the size of the memory block required by the database when
+   deserialized.
+
+#. :c:func:`hs_serialized_database_info`: given a serialized pattern database,
+   returns a string containing information about the database. This call is
+   analogous to :c:func:`hs_database_info`.
+
+.. note:: Hyperscan performs both version and platform compatibility checks
+   upon deserialization. The :c:func:`hs_deserialize_database` and
+   :c:func:`hs_deserialize_database_at` functions will only permit the
+   deserialization of databases compiled with (a) the same version of Hyperscan
+   and (b) platform features supported by the current host platform. See
+   :ref:`instr_specialization` for more information on platform specialization.
+
+===================
+The Runtime Library
+===================
+
+The main Hyperscan library (``libhs``) contains both the compiler and runtime
+portions of the library. This means that in order to support the Hyperscan
+compiler, which is written in C++, it requires C++ linkage and has a
+dependency on the C++ standard library.
+
+Many embedded applications require only the scanning ("runtime") portion of the
+Hyperscan library. In these cases, pattern compilation generally takes place on
+another host, and serialized pattern databases are delivered to the application
+for use.
+
+To support these applications without requiring the C++ dependency, a
+runtime-only version of the Hyperscan library, called ``libhs_runtime``, is also
+distributed. This library does not depend on the C++ standard library and
+provides all Hyperscan functions other that those used to compile databases.
diff --git a/libhs.pc.in b/libhs.pc.in
index b67f9de6..e16460e8 100644
--- a/libhs.pc.in
+++ b/libhs.pc.in
@@ -7,4 +7,5 @@ Name: libhs
 Description: Intel(R) Hyperscan Library
 Version: @HS_VERSION@
 Libs: -L${libdir} -lhs
+Libs.private: @PRIVATE_LIBS@
 Cflags: -I${includedir}/hs
diff --git a/src/fdr/CMakeLists.txt b/src/fdr/CMakeLists.txt
deleted file mode 100644
index 1436c3fc..00000000
--- a/src/fdr/CMakeLists.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-# The set of rules and other nastiness for generating FDR/Teddy source
-
-# we need to add these as explicit dependencies
-set(AUTOGEN_PY_FILES
-    arch.py
-    autogen.py
-    autogen_utils.py
-    base_autogen.py
-    fdr_autogen.py
-    teddy_autogen.py
-)
-
-function(fdr_autogen type out)
-    add_custom_command (
-        COMMENT "AUTOGEN ${out}"
-        OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${out}"
-        COMMAND ${PYTHON} "${CMAKE_CURRENT_SOURCE_DIR}/autogen.py" ${type} > "${CMAKE_CURRENT_BINARY_DIR}/${out}"
-        DEPENDS ${AUTOGEN_PY_FILES}
-        )
-    add_custom_target(autogen_${type} DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${out}")
-endfunction(fdr_autogen)
-
-#now build the functions
-fdr_autogen(runtime fdr_autogen.c)
-fdr_autogen(compiler fdr_autogen_compiler.cpp)
-fdr_autogen(teddy_runtime teddy_autogen.c)
-fdr_autogen(teddy_compiler teddy_autogen_compiler.cpp)
-
-set(fdr_GENERATED_SRC
-    ${PROJECT_BINARY_DIR}/src/fdr/fdr_autogen.c
-    ${PROJECT_BINARY_DIR}/src/fdr/fdr_autogen_compiler.cpp
-    ${PROJECT_BINARY_DIR}/src/fdr/teddy_autogen.c
-    ${PROJECT_BINARY_DIR}/src/fdr/teddy_autogen_compiler.cpp
-    PARENT_SCOPE)
-
-set_source_files_properties(${fdr_GENERATED_SRC} PROPERTIES GENERATED TRUE)
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
-
-
diff --git a/src/fdr/arch.py b/src/fdr/arch.py
deleted file mode 100755
index 83a31254..00000000
--- a/src/fdr/arch.py
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/usr/bin/python
-
-# Copyright (c) 2015, Intel Corporation
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#     * Redistributions of source code must retain the above copyright notice,
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright
-#       notice, this list of conditions and the following disclaimer in the
-#       documentation and/or other materials provided with the distribution.
-#     * Neither the name of Intel Corporation nor the names of its contributors
-#       may be used to endorse or promote products derived from this software
-#       without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import autogen_utils
-
-# wrapper for architectures
-
-class Arch:
-    def __init__(self, name, extensions = []):
-        self.name = name
-        self.extensions = extensions
-        self.target = None
-
-    def get_guard(self):
-        # these defines definitely fall into the "belt-and-suspenders"
-        # category of paranoia
-        if (self.guard_list == []):
-            return "#if 1"
-
-        return "#if " + " && ".join(self.guard_list)
-
-class X86Arch(Arch):
-    def __init__(self, name, extensions = []):
-        Arch.__init__(self, name, extensions)
-        self.guard_list = [ ]
-        self.target = "0"
-
-        if "AVX2" in extensions:
-            self.target += " | HS_CPU_FEATURES_AVX2"
-            self.guard_list += [ "defined(__AVX2__)" ]
-
-
-arch_x86_64            = X86Arch("x86_64", extensions = [ ])
-arch_x86_64_avx2       = X86Arch("x86_64_avx2", extensions = [ "AVX2" ])
diff --git a/src/fdr/autogen.py b/src/fdr/autogen.py
deleted file mode 100755
index e5b4f39e..00000000
--- a/src/fdr/autogen.py
+++ /dev/null
@@ -1,154 +0,0 @@
-#!/usr/bin/python
-
-# Copyright (c) 2015, Intel Corporation
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#     * Redistributions of source code must retain the above copyright notice,
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright
-#       notice, this list of conditions and the following disclaimer in the
-#       documentation and/or other materials provided with the distribution.
-#     * Neither the name of Intel Corporation nor the names of its contributors
-#       may be used to endorse or promote products derived from this software
-#       without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import sys
-from autogen_utils import *
-from fdr_autogen import *
-from teddy_autogen import *
-from arch import *
-
-# FDR setup
-
-# these are either produced - if the guard succeeds, or #defined to zeroes.
-# either the function or the zero is fine in our array of function pointers
-
-def produce_fdr_runtimes(l):
-    for m in l:
-        m.produce_code()
-
-def produce_fdr_compiles(l):
-    print "void getFdrDescriptions(vector<FDREngineDescription> *out) {"
-    print "    static const FDREngineDef defns[] = {"
-    for m in l:
-        m.produce_compile_call()
-    print "    };"
-    print "    out->clear();"
-    print "    for (size_t i = 0; i < ARRAY_LENGTH(defns); i++) {"
-    print "        out->push_back(FDREngineDescription(defns[i]));"
-    print "    }"
-    print "}"
-
-def build_fdr_matchers():
-    all_matchers = [ ]
-    strides = [ 1, 2, 4 ]
-
-    common = { "state_width" : 128, "num_buckets" : 8, "extract_frequency" : 8, "arch" : arch_x86_64 }
-    for s in strides:
-        all_matchers += [ M3(stride = s, **common) ]
-
-    return all_matchers
-
-# teddy setup
-
-def build_teddy_matchers():
-    all_matchers = [ ]
-
-    # AVX2
-    all_matchers += [ MTFast(arch = arch_x86_64_avx2, packed = False) ]
-    all_matchers += [ MTFast(arch = arch_x86_64_avx2, packed = True) ]
-    for n_msk in range(1, 5):
-        all_matchers += [ MTFat(arch = arch_x86_64_avx2, packed = False, num_masks = n_msk, num_buckets = 16) ]
-        all_matchers += [ MTFat(arch = arch_x86_64_avx2, packed = True, num_masks = n_msk, num_buckets = 16) ]
-
-    # SSE/SSE2/SSSE3
-    for n_msk in range(1, 5):
-        all_matchers += [ MT(arch = arch_x86_64, packed = False, num_masks = n_msk, num_buckets = 8) ]
-        all_matchers += [ MT(arch = arch_x86_64, packed = True, num_masks = n_msk, num_buckets = 8) ]
-
-    return all_matchers
-
-def produce_teddy_compiles(l):
-    print "void getTeddyDescriptions(vector<TeddyEngineDescription> *out) {"
-    print "    static const TeddyEngineDef defns[] = {"
-    for m in l:
-        m.produce_compile_call()
-    print "    };"
-    print "    out->clear();"
-    print "    for (size_t i = 0; i < ARRAY_LENGTH(defns); i++) {"
-    print "        out->push_back(TeddyEngineDescription(defns[i]));"
-    print "    }"
-    print "}"
-
-# see below - we don't produce our 'zeros' at the point of the teddy runtimes as they
-# are linked. So we either generate the function or we don't - then at the point of the
-# header in fdr_autogen.c we either generate the header or we #define the zero.
-
-def produce_teddy_runtimes(l):
-    # Since we're using -Wmissing-prototypes, we need headers first.
-    for m in l:
-	m.produce_guard()
-        print m.produce_header(visible = True, header_only = True)
-	m.close_guard()
-
-    for m in l:
-	m.produce_guard()
-        m.produce_code()
-	m.close_guard()
-
-# see produce_teddy_runtimes() comment for the rationale
-
-def produce_teddy_headers(l):
-    for m in l:
-	m.produce_guard()
-        print m.produce_header(visible = True, header_only = True)
-	m.produce_zero_alternative()
-
-# general utilities
-
-def make_fdr_function_pointers(matcher_list):
-    print  """
-typedef hwlm_error_t (*FDRFUNCTYPE)(const struct FDR *fdr, const struct FDR_Runtime_Args *a);
-static FDRFUNCTYPE funcs[] = {
-"""
-    all_funcs = ",\n".join([ "    %s" % m.get_name() for m in matcher_list ])
-    print all_funcs
-    print """
-};
-"""
-
-def assign_ids(matcher_list, next_id):
-    for m in matcher_list:
-        m.id = next_id
-        next_id += 1
-    return next_id
-
-# Main entry point
-
-m = build_fdr_matchers()
-next_id = assign_ids(m, 0)
-tm = build_teddy_matchers()
-next_id = assign_ids(tm, next_id)
-if sys.argv[1] == "compiler":
-    produce_fdr_compiles(m)
-elif sys.argv[1] == "runtime":
-    produce_fdr_runtimes(m)
-    produce_teddy_headers(tm)
-    make_fdr_function_pointers(m+tm)
-elif sys.argv[1] == "teddy_runtime":
-    produce_teddy_runtimes(tm)
-elif sys.argv[1] == "teddy_compiler":
-    produce_teddy_compiles(tm)
diff --git a/src/fdr/autogen_utils.py b/src/fdr/autogen_utils.py
deleted file mode 100755
index e3679ad9..00000000
--- a/src/fdr/autogen_utils.py
+++ /dev/null
@@ -1,285 +0,0 @@
-#!/usr/bin/python
-
-# Copyright (c) 2015, Intel Corporation
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#     * Redistributions of source code must retain the above copyright notice,
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright
-#       notice, this list of conditions and the following disclaimer in the
-#       documentation and/or other materials provided with the distribution.
-#     * Neither the name of Intel Corporation nor the names of its contributors
-#       may be used to endorse or promote products derived from this software
-#       without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import sys
-
-def fail_out(msg = ""):
-    print >>sys.stderr, "Internal failure in autogen.py: " + msg
-    sys.exit(1)
-
-class IntegerType:
-    def __init__(self, size):
-        self.size = size
-
-    def get_name(self):
-        return { 256: "m256", 128 : "m128", 64 : "u64a", 32 : "u32" , 16 : "u16", 8 : "u8"}[self.size]
-
-    def size_in_bytes(self):
-        return self.size / 8
-
-    def isSIMDOnIntel(self):
-        return False
-
-    def zero_expression(self):
-        return "0"
-
-    def constant_to_string(self, n):
-        if self.size == 64:
-            suffix = "ULL"
-        else:
-            suffix = ""
-        return "0x%x%s" % (n & ((1 << self.size) - 1), suffix)
-
-    def lowbits(self, n):
-        return (1 << n) - 1
-
-    def highbits(self, n):
-        return ~(self.lowbits(self.size - n))
-
-    def lowbit_mask(self, n):
-        return self.constant_to_string(self.lowbits(n))
-
-    def highbit_mask(self, n):
-        return self.constant_to_string(self.highbits(n))
-
-    def lowbit_extract_expr(self, expr_string, n):
-         return "(%s & %s)" % ( expr_string, self.lowbit_mask(n))
-
-    def highbit_extract_expr(self, expr_string, n):
-        return "(%s >> %d)" % (expr_string, self.size - n)
-
-    def flip_lowbits_expr(self, expr_string, n):
-         return "(%s ^ %s)" % ( expr_string, self.lowbit_mask(n))
-
-    def bit_extract_expr(self, expr_string, low, high):
-        lbm = self.lowbit_mask(high - low)
-        return "((%s >> %d) & %s)" % (expr_string, low, lbm)
-
-    # shifts are +ve if left and -ve if right
-    def shift_expr(self, expr_string, n):
-        if n <= -self.size or n >= self.size:
-            return self.zero_expression()
-        elif (n > 0):
-            return "(%s << %d)" % (expr_string, n)
-        elif (n < 0):
-            return "(%s >> %d)" % (expr_string, -n)
-        else:
-            return "(%s)" % (expr_string)
-
-    # code is:
-    # "normal" (always between buf and len) - the default
-    # "aligned" (means normal + aligned to a natural boundary)
-    # "cautious_forward" (means may go off the end of buf+len)
-    # "cautious_backwards" (means may go off the start of buf)
-    # "cautious_everywhere" (means may go off both)
-
-    def load_expr_data(self, offset = 0, code = "normal",
-                       base_string = "ptr", bounds_lo = "buf", bounds_hi = "buf + len"):
-        if code is "normal":
-            return "lv_%s(%s + %d, %s, %s)" % (self.get_name(), base_string, offset, bounds_lo, bounds_hi)
-        elif code is "aligned":
-            if self.size is 8:
-                fail_out("no aligned byte loads")
-            return "lv_%s_a(%s + %d, %s, %s)" % (self.get_name(), base_string, offset, bounds_lo, bounds_hi)
-        elif code is "cautious_forward":
-            return "lv_%s_cf(%s + %d, %s, %s)" % (self.get_name(), base_string, offset, bounds_lo, bounds_hi)
-        elif code is "cautious_backward":
-            return "lv_%s_cb(%s + %d, %s, %s)" % (self.get_name(), base_string, offset, bounds_lo, bounds_hi)
-        elif code is "cautious_everywhere":
-            return "lv_%s_ce(%s + %d, %s, %s)" % (self.get_name(), base_string, offset, bounds_lo, bounds_hi)
-
-
-class SIMDIntegerType(IntegerType):
-    def __init__(self, size):
-        IntegerType.__init__(self, size)
-
-    def isSIMDOnIntel(self):
-        return True
-
-    def zero_expression(self):
-        return "zeroes128()"
-
-    def lowbit_extract_expr(self, expr_string, n):
-        if (n <= 32):
-            tmpType = IntegerType(32)
-            tmpExpr = "movd(%s)" % expr_string
-        elif (32 < n <= 64):
-            tmpType = IntegerType(64)
-            tmpExpr = "movq(%s)" % expr_string
-        return tmpType.lowbit_extract_expr(tmpExpr, n)
-
-    def highbit_extract_expr(self, expr_string, n):
-        fail_out("Unimplemented high bit extract on m128")
-
-    def bit_extract_expr(self, expr_string, low, high, flip):
-        fail_out("Unimplemented bit extract on m128")
-
-    def shift_expr(self, expr_string, n):
-        if n % 8 != 0:
-            fail_out("Trying to shift a m128 by a bit granular value")
-
-        # should check that n is divisible by 8
-        if n <= -self.size or n >= self.size:
-            return self.zero_expression()
-        elif (n > 0):
-            return "_mm_slli_si128(%s, %s)" % (expr_string, n / 8)
-        elif (n < 0):
-            return "_mm_srli_si128(%s, %s)" % (expr_string, -n / 8)
-        else:
-            return "(%s)" % (expr_string)
-
-    def lowbit_mask(self, n):
-        if n % 8 != 0:
-            fail_out("Trying to make a lowbit mask in a m128 by a bit granular value")
-        return self.shift_expr("ones128()", -(128 - n))
-
-def getRequiredType(bits):
-    if bits == 128:
-        return SIMDIntegerType(bits)
-    for b in [ 8, 16, 32, 64]:
-        if (bits <= b):
-            return IntegerType(b)
-    return None
-
-class IntegerVariable:
-    def __init__(self, name, type):
-        self.name = name
-        self.type = type
-
-    def gen_initializer_stmt(self, initialization_string = None):
-        if initialization_string:
-            return "%s %s = %s;" % (self.type.get_name(), self.name, initialization_string)
-        else:
-            return "%s %s;" % (self.type.get_name(), self.name)
-
-
-class Step:
-    def __init__(self, context, offset = 0):
-        self.context = context
-        self.matcher = context.matcher
-        self.offset = offset
-        self.latency = 1
-        self.dependency_list = []
-        self.latest = None
-        self.context.add_step(self)
-
-    # return a string, complete with indentation
-    def emit(self):
-        indent = " " * (self.offset*2 + self.matcher.default_body_indent)
-        s = "\n".join( [ indent + line for line in self.val.split("\n")] )
-        if self.latest:
-            s += " // " + str(self.debug_step) + " L" + str(self.latency) + " LTST:%d" % self.latest
-            if self.dependency_list:
-                s += " Derps: "
-                for (d,l) in self.dependency_list:
-                    s += "%d/%d " % (d.debug_step,l)
-        return s
-
-    def add_dependency(self, step, anti_dependency = False, output_dependency = False):
-        if anti_dependency or output_dependency:
-            self.dependency_list += [ (step, 1) ]
-        else:
-            self.dependency_list += [ (step, step.latency) ]
-
-    def nv(self, type, var_name):
-        return self.context.new_var(self, type, var_name)
-
-    def gv(self, var_name, reader = True, writer = False):
-        return self.context.get_var(self, var_name, reader = reader, writer = writer)
-
-# utility steps, generic
-
-class LabelStep(Step):
-    def __init__(self, context, offset = 0, label_prefix = "off"):
-        Step.__init__(self, context, offset)
-        self.val = "%s%d: UNUSED;" % (label_prefix, offset)
-
-class OpenScopeStep(Step):
-    def __init__(self, context, offset = 0):
-        Step.__init__(self, context, offset)
-        self.val = "{"
-
-class CloseScopeStep(Step):
-    def __init__(self, context, offset = 0):
-        Step.__init__(self, context, offset)
-        self.val = "}"
-
-
-class CodeGenContext:
-    def __init__(self, matcher):
-        self.vars = {}
-        self.steps = []
-        self.ctr = 0
-        self.matcher = matcher
-        self.var_writer = {} # var to a single writer
-        self.var_readers = {} # var to a list of all the readers that read the last value
-
-    def new_var(self, step, type, var_name):
-        var = IntegerVariable(var_name, type)
-        self.vars[var_name] = var
-        self.var_writer[var_name] = step
-        return var
-
-    def get_var(self, step, var_name, reader = True, writer = False):
-        if reader:
-            writer_step = self.var_writer[var_name]
-            if writer_step:
-                step.add_dependency(writer_step)
-            self.var_readers.setdefault(var_name, []).append(step)
-        if writer and not reader:
-            if self.var_writer[var_name]:
-                step.add_dependency(self.var_writer[var_name], output_dependency = True)
-        if writer:
-            if self.var_readers.has_key(var_name):
-                for reader in [ r for r in self.var_readers[var_name] if r is not step ]:
-                    step.add_dependency(reader, anti_dependency = True)
-                self.var_readers[var_name] = []
-            self.var_writer[var_name] = step
-        return self.vars[var_name]
-
-    def add_step(self, step):
-        self.steps += [ step ]
-        step.debug_step = self.ctr
-        self.ctr += 1
-
-    def dontschedule(self, finals):
-        return "\n".join( [ s.emit() for s in self.steps ] )
-
-    def schedule(self, finals):
-        for f in finals:
-            f.latest = f.latency
-        worklist = finals
-        while worklist:
-            current = worklist[0]
-            worklist = worklist[1:]
-            for (dep, lat) in current.dependency_list:
-                if dep.latest is None or dep.latest < (current.latest + dep.latency):
-                    dep.latest = current.latest + lat
-                    if dep not in worklist:
-                        worklist += [ dep ]
-        self.steps.sort(reverse = True, key = lambda s : s.latest)
-        return "\n".join( [ s.emit() for s in self.steps ] )
diff --git a/src/fdr/base_autogen.py b/src/fdr/base_autogen.py
deleted file mode 100644
index c9cf1b37..00000000
--- a/src/fdr/base_autogen.py
+++ /dev/null
@@ -1,167 +0,0 @@
-#!/usr/bin/python
-
-# Copyright (c) 2015, Intel Corporation
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#     * Redistributions of source code must retain the above copyright notice,
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright
-#       notice, this list of conditions and the following disclaimer in the
-#       documentation and/or other materials provided with the distribution.
-#     * Neither the name of Intel Corporation nor the names of its contributors
-#       may be used to endorse or promote products derived from this software
-#       without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import sys
-from autogen_utils import *
-from base_autogen import *
-from string import Template
-
-class MatcherBase:
-
-    def __init__(self):
-        pass
-
-    def get_name(self):
-        return "fdr_exec_%03d" % self.id
-
-    def produce_header(self, visible, header_only = False):
-        s = ""
-        if not visible:
-            s += "static never_inline"
-        s += """
-hwlm_error_t %s(UNUSED const struct FDR *fdr,
-                UNUSED const struct FDR_Runtime_Args * a)""" % self.get_name()
-        if header_only:
-            s += ";"
-        else:
-            s += "{"
-        s += "\n"
-        return s
-
-    def produce_guard(self):
-	print self.arch.get_guard()
-    
-    def produce_zero_alternative(self):
-	print """
-#else
-#define %s 0
-#endif
-""" % self.get_name()
-
-    # trivial function for documentation/modularity
-    def close_guard(self):
-	print "#endif"
-
-    def produce_common_declarations(self):
-        return """
-    const u8 * buf = a->buf;
-    const size_t len = a->len;
-    const u8 * ptr = buf + a->start_offset;
-    hwlmcb_rv_t controlVal = *a->groups;
-    hwlmcb_rv_t * control = &controlVal;
-    u32 floodBackoff = FLOOD_BACKOFF_START;
-    const u8 * tryFloodDetect = a->firstFloodDetect;
-    UNUSED u32 bit, bitRem, confSplit, idx;
-    u32 byte, cf;
-    const struct FDRConfirm *fdrc;
-    u32 last_match = (u32)-1;
-"""
-
-    def produce_continue_check(self):
-        return """if (P0(controlVal == HWLM_TERMINATE_MATCHING)) {
-    *a->groups = controlVal;
-    return HWLM_TERMINATED;
-}
-"""
-    def produce_flood_check(self):
-        return """
-        if (P0(ptr > tryFloodDetect)) {
-            tryFloodDetect = floodDetect(fdr, a, &ptr, tryFloodDetect, &floodBackoff, &controlVal, iterBytes);
-            if (P0(controlVal == HWLM_TERMINATE_MATCHING)) {
-                *a->groups = controlVal;
-                return HWLM_TERMINATED;
-            }
-        }
-"""
-
-    def produce_footer(self):
-        return """
-    *a->groups = controlVal;
-    return HWLM_SUCCESS;
-}
-"""
-
-    def produce_confirm_base(self, conf_var_name, conf_var_size, offset, cautious, enable_confirmless, do_bailout = False):
-        if cautious:
-            caution_string = "VECTORING"
-        else:
-            caution_string = "NOT_CAUTIOUS"
-        conf_split_mask = IntegerType(32).constant_to_string(
-                            self.conf_top_level_split - 1)
-        if enable_confirmless:
-            quick_check_string = """
-        if (!fdrc->mult) {
-            u32 id = fdrc->nBitsOrSoleID;
-            if ((last_match == id) && (fdrc->flags & NoRepeat))
-                continue;
-           last_match = id;
-           controlVal = a->cb(ptr+byte-buf, ptr+byte-buf, id, a->ctxt);
-           continue;
-        } """
-        else:
-            quick_check_string = ""
-        if do_bailout:
-            bailout_string = """
-        if ((ptr + byte < buf + a->start_offset) || (ptr + byte >= buf + len)) continue;"""
-        else:
-            bailout_string = ""
-
-        return Template("""
-if (P0(!!$CONFVAR)) {
-    do  {
-        bit = findAndClearLSB_$CONFVAR_SIZE(&$CONFVAR);
-        byte  = bit / $NUM_BUCKETS + $OFFSET;
-        bitRem  = bit % $NUM_BUCKETS;
-        $BAILOUT_STRING
-        confSplit = *(ptr+byte) & $SPLIT_MASK;
-        idx = confSplit * $NUM_BUCKETS + bitRem;
-        cf = confBase[idx];
-        if (!cf)
-            continue;
-        fdrc = (const struct FDRConfirm *)((const u8 *)confBase + cf);
-        if (!(fdrc->groups & *control))
-            continue;
-        $QUICK_CHECK_STRING
-        confWithBit(fdrc, a, ptr - buf + byte, $CAUTION_STRING, $CONF_PULL_BACK, control, &last_match);
-    } while(P0(!!$CONFVAR));
-    if (P0(controlVal == HWLM_TERMINATE_MATCHING)) {
-        *a->groups = controlVal;
-        return HWLM_TERMINATED;
-    }
-}""").substitute(CONFVAR = conf_var_name,
-                 CONFVAR_SIZE = conf_var_size,
-                 NUM_BUCKETS = self.num_buckets,
-                 OFFSET = offset,
-                 SPLIT_MASK = conf_split_mask,
-                 QUICK_CHECK_STRING = quick_check_string,
-                 BAILOUT_STRING = bailout_string,
-                 CAUTION_STRING = caution_string,
-                 CONF_PULL_BACK = self.conf_pull_back)
-
-
-def indent(block, depth):
-    return "\n".join([ (" " * (4*depth)) + line for line in block.splitlines() ] )
diff --git a/src/fdr/engine_description.h b/src/fdr/engine_description.h
index 3c3026c3..09b16179 100644
--- a/src/fdr/engine_description.h
+++ b/src/fdr/engine_description.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -55,6 +55,7 @@ public:
     u32 getNumBuckets() const { return numBuckets; }
     u32 getConfirmPullBackDistance() const { return confirmPullBackDistance; }
     u32 getConfirmTopLevelSplit() const { return confirmTopLevelSplit; }
+    void setConfirmTopLevelSplit(u32 split) { confirmTopLevelSplit = split; }
 
     bool isValidOnTarget(const target_t &target_in) const;
     virtual u32 getDefaultFloodSuffixLength() const = 0;
diff --git a/src/fdr/fdr.c b/src/fdr/fdr.c
index f83a4265..ff69853e 100644
--- a/src/fdr/fdr.c
+++ b/src/fdr/fdr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,34 +26,790 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "util/simd_utils.h"
-
-#define P0(cnd) unlikely(cnd)
-
 #include "fdr.h"
-#include "fdr_internal.h"
-#include "teddy_internal.h"
-
-#include "flood_runtime.h"
-
 #include "fdr_confirm.h"
 #include "fdr_confirm_runtime.h"
-#include "fdr_streaming_runtime.h"
+#include "fdr_internal.h"
 #include "fdr_loadval.h"
-#include "fdr_autogen.c"
+#include "fdr_streaming_runtime.h"
+#include "flood_runtime.h"
+#include "teddy.h"
+#include "teddy_internal.h"
+#include "util/simd_utils.h"
+#include "util/simd_utils_ssse3.h"
+
+/** \brief number of bytes processed in each iteration */
+#define ITER_BYTES          16
+
+/** \brief total zone buffer size */
+#define ZONE_TOTAL_SIZE     64
+
+/** \brief maximum number of allowed zones */
+#define ZONE_MAX            3
+
+/** \brief zone information.
+ *
+ * Zone represents a region of data to scan in FDR.
+ *
+ * The incoming buffer is to split in multiple zones to ensure two properties:
+ * 1: that we can read 8? bytes behind to generate a hash safely
+ * 2: that we can read the byte after the current byte (domain > 8)
+ */
+struct zone {
+    /** \brief copied buffer, used only when it is a boundary zone. */
+    u8 ALIGN_CL_DIRECTIVE buf[ZONE_TOTAL_SIZE];
+
+    /** \brief shift amount for fdr state to avoid unwanted match. */
+    u8 shift;
+
+    /** \brief if boundary zone, start points into the zone buffer after the
+     * pre-padding. Otherwise, points to the main buffer, appropriately. */
+    const u8 *start;
+
+    /** \brief if boundary zone, end points to the end of zone. Otherwise,
+     * pointer to the main buffer, appropriately. */
+    const u8 *end;
+
+    /** \brief the amount to adjust to go from a pointer in the zones region
+     * (between start and end) to a pointer in the original data buffer. */
+    ptrdiff_t zone_pointer_adjust;
+
+    /** \brief firstFloodDetect from FDR_Runtime_Args for non-boundary zones,
+     * otherwise end of the zone buf. floodPtr always points inside the same
+     * buffer as the start pointe. */
+    const u8 *floodPtr;
+};
+
+static
+const ALIGN_CL_DIRECTIVE u8 zone_or_mask[ITER_BYTES+1][ITER_BYTES] = {
+    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+      0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 },
+    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 },
+    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
+};
+
+/* generates an initial state mask based on the last byte-ish of history rather
+ * than being all accepting. If there is no history to consider, the state is
+ * generated based on the minimum length of each bucket in order to prevent
+ * confirms.
+ */
+static really_inline
+m128 getInitState(const struct FDR *fdr, u8 len_history, const u8 *ft,
+                  const struct zone *z) {
+    m128 s;
+    if (len_history) {
+        /* +1: the zones ensure that we can read the byte at z->end */
+        u32 tmp = lv_u16(z->start + z->shift - 1, z->buf, z->end + 1);
+        tmp &= fdr->domainMask;
+        s = *((const m128 *)ft + tmp);
+        s = shiftRight8Bits(s);
+    } else {
+        s = fdr->start;
+    }
+    return s;
+}
+
+static really_inline
+void get_conf_stride_1(const u8 *itPtr, const u8 *start_ptr, const u8 *end_ptr,
+                       u64a domain_mask_adjusted, const u8 *ft, u64a *conf0,
+                       u64a *conf8, m128 *s) {
+    /* +1: the zones ensure that we can read the byte at z->end */
+
+    u64a current_data_0;
+    u64a current_data_8;
+
+    current_data_0 = lv_u64a(itPtr + 0, start_ptr, end_ptr);
+    u64a v7 = (lv_u16(itPtr + 7, start_ptr, end_ptr + 1) << 1) &
+               domain_mask_adjusted;
+    u64a v0 = (current_data_0 << 1) & domain_mask_adjusted;
+    u64a v1 = (current_data_0 >> 7) & domain_mask_adjusted;
+    u64a v2 = (current_data_0 >> 15) & domain_mask_adjusted;
+    u64a v3 = (current_data_0 >> 23) & domain_mask_adjusted;
+    u64a v4 = (current_data_0 >> 31) & domain_mask_adjusted;
+    u64a v5 = (current_data_0 >> 39) & domain_mask_adjusted;
+    u64a v6 = (current_data_0 >> 47) & domain_mask_adjusted;
+    current_data_8 = lv_u64a(itPtr + 8, start_ptr, end_ptr);
+    u64a v15 = (lv_u16(itPtr + 15, start_ptr, end_ptr + 1) << 1) &
+               domain_mask_adjusted;
+    u64a v8 = (current_data_8 << 1) & domain_mask_adjusted;
+    u64a v9 = (current_data_8 >> 7) & domain_mask_adjusted;
+    u64a v10 = (current_data_8 >> 15) & domain_mask_adjusted;
+    u64a v11 = (current_data_8 >> 23) & domain_mask_adjusted;
+    u64a v12 = (current_data_8 >> 31) & domain_mask_adjusted;
+    u64a v13 = (current_data_8 >> 39) & domain_mask_adjusted;
+    u64a v14 = (current_data_8 >> 47) & domain_mask_adjusted;
+
+    m128 st0 = *(const m128 *)(ft + v0*8);
+    m128 st1 = *(const m128 *)(ft + v1*8);
+    m128 st2 = *(const m128 *)(ft + v2*8);
+    m128 st3 = *(const m128 *)(ft + v3*8);
+    m128 st4 = *(const m128 *)(ft + v4*8);
+    m128 st5 = *(const m128 *)(ft + v5*8);
+    m128 st6 = *(const m128 *)(ft + v6*8);
+    m128 st7 = *(const m128 *)(ft + v7*8);
+    m128 st8 = *(const m128 *)(ft + v8*8);
+    m128 st9 = *(const m128 *)(ft + v9*8);
+    m128 st10 = *(const m128 *)(ft + v10*8);
+    m128 st11 = *(const m128 *)(ft + v11*8);
+    m128 st12 = *(const m128 *)(ft + v12*8);
+    m128 st13 = *(const m128 *)(ft + v13*8);
+    m128 st14 = *(const m128 *)(ft + v14*8);
+    m128 st15 = *(const m128 *)(ft + v15*8);
+
+    st1 = byteShiftLeft128(st1, 1);
+    st2 = byteShiftLeft128(st2, 2);
+    st3 = byteShiftLeft128(st3, 3);
+    st4 = byteShiftLeft128(st4, 4);
+    st5 = byteShiftLeft128(st5, 5);
+    st6 = byteShiftLeft128(st6, 6);
+    st7 = byteShiftLeft128(st7, 7);
+    st9 = byteShiftLeft128(st9, 1);
+    st10 = byteShiftLeft128(st10, 2);
+    st11 = byteShiftLeft128(st11, 3);
+    st12 = byteShiftLeft128(st12, 4);
+    st13 = byteShiftLeft128(st13, 5);
+    st14 = byteShiftLeft128(st14, 6);
+    st15 = byteShiftLeft128(st15, 7);
+
+    *s = or128(*s, st0);
+    *s = or128(*s, st1);
+    *s = or128(*s, st2);
+    *s = or128(*s, st3);
+    *s = or128(*s, st4);
+    *s = or128(*s, st5);
+    *s = or128(*s, st6);
+    *s = or128(*s, st7);
+    *conf0 = movq(*s);
+    *s = byteShiftRight128(*s, 8);
+    *conf0 ^= ~0ULL;
+
+    *s = or128(*s, st8);
+    *s = or128(*s, st9);
+    *s = or128(*s, st10);
+    *s = or128(*s, st11);
+    *s = or128(*s, st12);
+    *s = or128(*s, st13);
+    *s = or128(*s, st14);
+    *s = or128(*s, st15);
+    *conf8 = movq(*s);
+    *s = byteShiftRight128(*s, 8);
+    *conf8 ^= ~0ULL;
+}
+
+static really_inline
+void get_conf_stride_2(const u8 *itPtr, const u8 *start_ptr, const u8 *end_ptr,
+                       u64a domain_mask_adjusted, const u8 *ft, u64a *conf0,
+                       u64a *conf8, m128 *s) {
+    u64a current_data_0;
+    u64a current_data_8;
+
+    current_data_0 = lv_u64a(itPtr + 0, start_ptr, end_ptr);
+    u64a v0 = (current_data_0 << 1) & domain_mask_adjusted;
+    u64a v2 = (current_data_0 >> 15) & domain_mask_adjusted;
+    u64a v4 = (current_data_0 >> 31) & domain_mask_adjusted;
+    u64a v6 = (current_data_0 >> 47) & domain_mask_adjusted;
+    current_data_8 = lv_u64a(itPtr + 8, start_ptr, end_ptr);
+    u64a v8 = (current_data_8 << 1) & domain_mask_adjusted;
+    u64a v10 = (current_data_8 >> 15) & domain_mask_adjusted;
+    u64a v12 = (current_data_8 >> 31) & domain_mask_adjusted;
+    u64a v14 = (current_data_8 >> 47) & domain_mask_adjusted;
+
+    m128 st0 = *(const m128 *)(ft + v0*8);
+    m128 st2 = *(const m128 *)(ft + v2*8);
+    m128 st4 = *(const m128 *)(ft + v4*8);
+    m128 st6 = *(const m128 *)(ft + v6*8);
+    m128 st8 = *(const m128 *)(ft + v8*8);
+    m128 st10 = *(const m128 *)(ft + v10*8);
+    m128 st12 = *(const m128 *)(ft + v12*8);
+    m128 st14 = *(const m128 *)(ft + v14*8);
+
+    st2 = byteShiftLeft128(st2, 2);
+    st4 = byteShiftLeft128(st4, 4);
+    st6 = byteShiftLeft128(st6, 6);
+    st10 = byteShiftLeft128(st10, 2);
+    st12 = byteShiftLeft128(st12, 4);
+    st14 = byteShiftLeft128(st14, 6);
+
+    *s = or128(*s, st0);
+    *s = or128(*s, st2);
+    *s = or128(*s, st4);
+    *s = or128(*s, st6);
+    *conf0 = movq(*s);
+    *s = byteShiftRight128(*s, 8);
+    *conf0 ^= ~0ULL;
+
+    *s = or128(*s, st8);
+    *s = or128(*s, st10);
+    *s = or128(*s, st12);
+    *s = or128(*s, st14);
+    *conf8 = movq(*s);
+    *s = byteShiftRight128(*s, 8);
+    *conf8 ^= ~0ULL;
+}
+
+static really_inline
+void get_conf_stride_4(const u8 *itPtr, const u8 *start_ptr, const u8 *end_ptr,
+                       u64a domain_mask_adjusted, const u8 *ft, u64a *conf0,
+                       u64a *conf8, m128 *s) {
+    u64a current_data_0;
+    u64a current_data_8;
+
+    current_data_0 = lv_u64a(itPtr + 0, start_ptr, end_ptr);
+    u64a v0 = (current_data_0 << 1) & domain_mask_adjusted;
+    u64a v4 = (current_data_0 >> 31) & domain_mask_adjusted;
+    current_data_8 = lv_u64a(itPtr + 8, start_ptr, end_ptr);
+    u64a v8 = (current_data_8 << 1) & domain_mask_adjusted;
+    u64a v12 = (current_data_8 >> 31) & domain_mask_adjusted;
+
+    m128 st0 = *(const m128 *)(ft + v0*8);
+    m128 st4 = *(const m128 *)(ft + v4*8);
+    m128 st8 = *(const m128 *)(ft + v8*8);
+    m128 st12 = *(const m128 *)(ft + v12*8);
+
+    st4 = byteShiftLeft128(st4, 4);
+    st12 = byteShiftLeft128(st12, 4);
+
+    *s = or128(*s, st0);
+    *s = or128(*s, st4);
+    *conf0 = movq(*s);
+    *s = byteShiftRight128(*s, 8);
+    *conf0 ^= ~0ULL;
+
+    *s = or128(*s, st8);
+    *s = or128(*s, st12);
+    *conf8 = movq(*s);
+    *s = byteShiftRight128(*s, 8);
+    *conf8 ^= ~0ULL;
+}
+
+static really_inline
+void do_confirm_fdr(u64a *conf, u8 offset, hwlmcb_rv_t *controlVal,
+                    const u32 *confBase, const struct FDR_Runtime_Args *a,
+                    const u8 *ptr, hwlmcb_rv_t *control, u32 *last_match_id,
+                    struct zone *z) {
+    const u8 bucket = 8;
+    const u8 pullback = 1;
+
+    if (likely(!*conf)) {
+        return;
+    }
+
+    /* ptr is currently referring to a location in the zone's buffer, we also
+     * need a pointer in the original, main buffer for the final string compare.
+     */
+    const u8 *ptr_main = (const u8 *)((uintptr_t)ptr + z->zone_pointer_adjust);
+
+    const u8 *confLoc = ptr;
+
+    do  {
+        u32 bit = findAndClearLSB_64(conf);
+        u32 byte = bit / bucket + offset;
+        u32 bitRem = bit % bucket;
+        u32 confSplit = *(ptr + byte);
+        u32 idx = confSplit * bucket + bitRem;
+        u32 cf = confBase[idx];
+        if (!cf) {
+            continue;
+        }
+        const struct FDRConfirm *fdrc = (const struct FDRConfirm *)
+                                        ((const u8 *)confBase + cf);
+        if (!(fdrc->groups & *control)) {
+            continue;
+        }
+        if (!fdrc->mult) {
+            u32 id = fdrc->nBitsOrSoleID;
+            if ((*last_match_id == id) && (fdrc->flags & NoRepeat)) {
+                continue;
+            }
+           *last_match_id = id;
+           *controlVal = a->cb(ptr_main + byte - a->buf,
+                               ptr_main + byte - a->buf, id, a->ctxt);
+           continue;
+        }
+        u64a confVal = unaligned_load_u64a(confLoc + byte - sizeof(u64a));
+        confWithBit(fdrc, a, ptr_main - a->buf + byte, pullback,
+                    control, last_match_id, confVal);
+    } while (unlikely(!!*conf));
+}
+
+static really_inline
+void dumpZoneInfo(UNUSED struct zone *z, UNUSED size_t zone_id) {
+#ifdef DEBUG
+    DEBUG_PRINTF("zone: zone=%zu, bufPtr=%p\n", zone_id, z->buf);
+    DEBUG_PRINTF("zone: startPtr=%p, endPtr=%p, shift=%u\n",
+                 z->start, z->end, z->shift);
+    DEBUG_PRINTF("zone: zone_pointer_adjust=%zd, floodPtr=%p\n",
+                 z->zone_pointer_adjust, z->floodPtr);
+    DEBUG_PRINTF("zone buf:");
+    for (size_t i = 0; i < ZONE_TOTAL_SIZE; i++) {
+        if (i % 8 == 0) {
+            printf("_");
+        }
+        if (z->buf[i]) {
+            printf("%02x", z->buf[i]);
+        } else {
+            printf("..");
+        }
+    }
+    printf("\n");
+#endif
+};
+
+/**
+ * \brief Updates attributes for non-boundary region zone.
+ */
+static really_inline
+void createMainZone(const u8 *flood, const u8 *begin, const u8 *end,
+                    struct zone *z) {
+    z->zone_pointer_adjust = 0; /* zone buffer is the main buffer */
+    z->start = begin;
+    z->end = end;
+    z->floodPtr = flood;
+    z->shift = 0;
+}
+
+/**
+ * \brief Create zone for short cases (<= ITER_BYTES).
+ *
+ * For this case we need to copy everything into the zone's internal buffer.
+ *
+ * We need to ensure that we run over real data if it exists (in history or
+ * before zone begin). We also need to ensure 8 bytes before any data being
+ * matched can be read (to perform a conf hash).
+ *
+ * We also need to ensure that the data at z->end can be read.
+ *
+ * Hence, the zone consists of:
+ *     16 bytes of history,
+ *     1 - 24 bytes of data form the buffer (ending at end),
+ *     1 byte of final padding
+ */
+static really_inline
+void createShortZone(const u8 *buf, const u8 *hend, const u8 *begin,
+                     const u8 *end, struct zone *z) {
+    /* the floodPtr for BOUNDARY zones are maximum of end of zone buf to avoid
+     * the checks in boundary zone. */
+    z->floodPtr = z->buf + ZONE_TOTAL_SIZE;
+
+    ptrdiff_t z_len = end - begin;
+    assert(z_len > 0);
+    assert(z_len <= ITER_BYTES);
+
+    z->shift = ITER_BYTES - z_len; /* ignore bytes outside region specified */
+
+    static const size_t ZONE_SHORT_DATA_OFFSET = 16; /* after history */
+
+    /* we are guaranteed to always have 16 initialised bytes at the end of
+     * the history buffer (they may be garbage coming from the stream state
+     * preceding hbuf, but bytes that don't correspond to actual history
+     * shouldn't affect computations). */
+    *(m128 *)z->buf = loadu128(hend - sizeof(m128));
+
+    /* The amount of data we have to copy from main buffer. */
+    size_t copy_len = MIN((size_t)(end - buf),
+                          ITER_BYTES + sizeof(CONF_TYPE));
+
+    u8 *zone_data = z->buf + ZONE_SHORT_DATA_OFFSET;
+    switch (copy_len) {
+    case 1:
+        *zone_data = *(end - 1);
+        break;
+    case 2:
+        *(u16 *)zone_data = unaligned_load_u16(end - 2);
+        break;
+    case 3:
+        *(u16 *)zone_data = unaligned_load_u16(end - 3);
+        *(zone_data + 2) = *(end - 1);
+        break;
+    case 4:
+        *(u32 *)zone_data = unaligned_load_u32(end - 4);
+        break;
+    case 5:
+    case 6:
+    case 7:
+        /* perform copy with 2 overlapping 4-byte chunks from buf. */
+        *(u32 *)zone_data = unaligned_load_u32(end - copy_len);
+        unaligned_store_u32(zone_data + copy_len - sizeof(u32),
+                            unaligned_load_u32(end - sizeof(u32)));
+        break;
+    case 8:
+        *(u64a *)zone_data = unaligned_load_u64a(end - 8);
+        break;
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+        /* perform copy with 2 overlapping 8-byte chunks from buf. */
+        *(u64a *)zone_data = unaligned_load_u64a(end - copy_len);
+        unaligned_store_u64a(zone_data + copy_len - sizeof(u64a),
+                             unaligned_load_u64a(end - sizeof(u64a)));
+        break;
+    case 16:
+        /* copy 16-bytes from buf. */
+        *(m128 *)zone_data = loadu128(end - 16);
+        break;
+    default:
+        assert(copy_len <= sizeof(m128) + sizeof(u64a));
+
+        /* perform copy with (potentially overlapping) 8-byte and 16-byte chunks.
+         */
+        *(u64a *)zone_data = unaligned_load_u64a(end - copy_len);
+        storeu128(zone_data + copy_len - sizeof(m128),
+                  loadu128(end - sizeof(m128)));
+        break;
+    }
+
+    /* set the start and end location of the zone buf
+     * to be scanned */
+    u8 *z_end = z->buf + ZONE_SHORT_DATA_OFFSET + copy_len;
+    assert(ZONE_SHORT_DATA_OFFSET + copy_len >= ITER_BYTES);
+
+    /* copy the post-padding byte; this is required for domain > 8 due to
+     * overhang */
+    *z_end = 0;
+
+    z->end = z_end;
+    z->start = z_end - ITER_BYTES;
+    z->zone_pointer_adjust = (ptrdiff_t)((uintptr_t)end - (uintptr_t)z_end);
+    assert(z->start + z->shift == z_end - z_len);
+}
+
+/**
+ * \brief Create a zone for the start region.
+ *
+ * This function requires that there is > ITER_BYTES of data in the buffer to
+ * scan. The start zone itself is always responsible for scanning exactly
+ * ITER_BYTES of data - there are no warmup/junk bytes scanned.
+ *
+ * This zone ensures that the byte at z->end can be read and corresponds to
+ * the next byte of data.
+ *
+ * 8 bytes of history data are provided before z->start to allow proper hash
+ * generation in streaming mode. If buf != begin, upto 8 bytes of data
+ * prior to begin is also provided.
+ *
+ * Although we are not interested in bare literals which start before begin
+ * if buf != begin, lookarounds associated with the literal may require
+ * the data prior to begin for hash purposes.
+ */
+static really_inline
+void createStartZone(const u8 *buf, const u8 *hend, const u8 *begin,
+                     struct zone *z) {
+    assert(ITER_BYTES == sizeof(m128));
+    assert(sizeof(CONF_TYPE) == 8);
+    static const size_t ZONE_START_BEGIN = sizeof(CONF_TYPE);
+
+    const u8 *end = begin + ITER_BYTES;
+
+    /* set floodPtr to the end of zone buf to avoid checks in start zone */
+    z->floodPtr = z->buf + ZONE_TOTAL_SIZE;
+
+    z->shift = 0; /* we are processing ITER_BYTES of real data */
+
+    /* we are guaranteed to always have 16 initialised bytes at the end of the
+     * history buffer (they may be garbage coming from the stream state
+     * preceding hbuf, but bytes that don't correspond to actual history
+     * shouldn't affect computations). However, for start zones, history is only
+     * required for conf hash purposes so we only need 8 bytes */
+    unaligned_store_u64a(z->buf, unaligned_load_u64a(hend - sizeof(u64a)));
+
+    /* The amount of data we have to copy from main buffer. */
+    size_t copy_len = MIN((size_t)(end - buf),
+                          ITER_BYTES + sizeof(CONF_TYPE));
+    assert(copy_len >= 16);
+
+    /* copy the post-padding byte; this is required for domain > 8 due to
+     * overhang. The start requires that there is data after the zone so it
+     * it safe to dereference end */
+    z->buf[ZONE_START_BEGIN + copy_len] = *end;
+
+    /* set the start and end location of the zone buf to be scanned */
+    u8 *z_end = z->buf + ZONE_START_BEGIN + copy_len;
+    z->end = z_end;
+    z->start = z_end - ITER_BYTES;
+
+    /* copy the first 8 bytes of the valid region */
+    unaligned_store_u64a(z->buf + ZONE_START_BEGIN,
+                         unaligned_load_u64a(end - copy_len));
+
+    /* copy the last 16 bytes, may overlap with the previous 8 byte write */
+    storeu128(z_end - sizeof(m128), loadu128(end - sizeof(m128)));
+
+    z->zone_pointer_adjust = (ptrdiff_t)((uintptr_t)end - (uintptr_t)z_end);
+}
+
+/**
+ * \brief Create a zone for the end region.
+ *
+ * This function requires that there is > ITER_BYTES of data in the buffer to
+ * scan. The end zone, however, is only responsible for a scanning the <=
+ * ITER_BYTES rump of data. The end zone is required to handle a full ITER_BYTES
+ * iteration as the main loop cannot handle the last byte of the buffer.
+ *
+ * This zone ensures that the byte at z->end can be read by filling it with a
+ * padding character.
+ *
+ * Upto 8 bytes of data prior to begin is also provided for the purposes of
+ * generating hashes. History is not copied, as all locations which require
+ * history for generating a hash are the responsiblity of the start zone.
+ */
+static really_inline
+void createEndZone(const u8 *buf, const u8 *begin, const u8 *end,
+                   struct zone *z) {
+    /* the floodPtr for BOUNDARY zones are maximum of end of zone buf to avoid
+     * the checks in boundary zone. */
+    z->floodPtr = z->buf + ZONE_TOTAL_SIZE;
+
+    ptrdiff_t z_len = end - begin;
+    assert(z_len > 0);
+    assert(z_len <= ITER_BYTES);
+
+    z->shift = ITER_BYTES - z_len;
+
+    /* The amount of data we have to copy from main buffer. */
+    size_t copy_len = MIN((size_t)(end - buf),
+                          ITER_BYTES + sizeof(CONF_TYPE));
+    assert(copy_len >= 16);
+
+    /* copy the post-padding byte; this is required for domain > 8 due to
+     * overhang */
+    z->buf[copy_len] = 0;
+
+    /* set the start and end location of the zone buf
+     * to be scanned */
+    u8 *z_end = z->buf + copy_len;
+    z->end = z_end;
+    z->start = z_end - ITER_BYTES;
+    assert(z->start + z->shift == z_end - z_len);
+
+    /* copy the first 8 bytes of the valid region */
+    unaligned_store_u64a(z->buf, unaligned_load_u64a(end - copy_len));
+
+    /* copy the last 16 bytes, may overlap with the previous 8 byte write */
+    storeu128(z_end - sizeof(m128), loadu128(end - sizeof(m128)));
+
+    z->zone_pointer_adjust = (ptrdiff_t)((uintptr_t)end - (uintptr_t)z_end);
+}
+
+/**
+ * \brief Prepare zones.
+ *
+ * This function prepares zones with actual buffer and some padded bytes.
+ * The actual ITER_BYTES bytes in zone is preceded by main buf and/or
+ * history buf and succeeded by padded bytes possibly from main buf,
+ * if available.
+ */
+static really_inline
+size_t prepareZones(const u8 *buf, size_t len, const u8 *hend,
+                    size_t start, const u8 *flood, struct zone *zoneArr) {
+    const u8 *ptr = buf + start;
+    size_t remaining = len - start;
+
+    if (remaining <= ITER_BYTES) {
+        /* enough bytes to make only one zone */
+        createShortZone(buf, hend, ptr, buf + len, &zoneArr[0]);
+        return 1;
+    }
+
+    /* enough bytes to make more than one zone */
+
+    size_t numZone = 0;
+    createStartZone(buf, hend, ptr, &zoneArr[numZone++]);
+    ptr += ITER_BYTES;
+
+    assert(ptr < buf + len);
+
+    /* find maximum buffer location that the main zone can scan
+     * - must be a multiple of ITER_BYTES, and
+     * - cannot contain the last byte (due to overhang)
+     */
+    const u8 *main_end = buf + start + ROUNDDOWN_N(len - start - 1, ITER_BYTES);
+    assert(main_end >= ptr);
+
+    /* create a zone if multiple of ITER_BYTES are found */
+    if (main_end != ptr) {
+        createMainZone(flood, ptr, main_end, &zoneArr[numZone++]);
+        ptr = main_end;
+    }
+    /* create a zone with rest of the data from the main buffer */
+    createEndZone(buf, ptr, buf + len, &zoneArr[numZone++]);
+    return numZone;
+}
+
+#define INVALID_MATCH_ID (~0U)
+
+#define FDR_MAIN_LOOP(zz, s, get_conf_fn)                                   \
+    do {                                                                    \
+        const u8 *tryFloodDetect = zz->floodPtr;                            \
+        const u8 *start_ptr = zz->start;                                    \
+        const u8 *end_ptr = zz->end;                                        \
+                                                                            \
+        for (const u8 *itPtr = start_ptr; itPtr + ITER_BYTES <= end_ptr;    \
+            itPtr += ITER_BYTES) {                                          \
+            if (unlikely(itPtr > tryFloodDetect)) {                         \
+                tryFloodDetect = floodDetect(fdr, a, &itPtr, tryFloodDetect,\
+                                             &floodBackoff, &controlVal,    \
+                                             ITER_BYTES);                   \
+                if (unlikely(controlVal == HWLM_TERMINATE_MATCHING)) {      \
+                    return HWLM_TERMINATED;                                 \
+                }                                                           \
+            }                                                               \
+            __builtin_prefetch(itPtr + (ITER_BYTES*4));                     \
+            u64a conf0;                                                     \
+            u64a conf8;                                                     \
+            get_conf_fn(itPtr, start_ptr, end_ptr, domain_mask_adjusted,    \
+                        ft, &conf0, &conf8, &s);                            \
+            do_confirm_fdr(&conf0, 0, &controlVal, confBase, a, itPtr,      \
+                           control, &last_match_id, zz);                    \
+            do_confirm_fdr(&conf8, 8, &controlVal, confBase, a, itPtr,      \
+                           control, &last_match_id, zz);                    \
+            if (unlikely(controlVal == HWLM_TERMINATE_MATCHING)) {          \
+                return HWLM_TERMINATED;                                     \
+            }                                                               \
+        } /* end for loop */                                                \
+    } while (0)                                                             \
+
+static never_inline
+hwlm_error_t fdr_engine_exec(const struct FDR *fdr,
+                             const struct FDR_Runtime_Args *a) {
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    u32 last_match_id = INVALID_MATCH_ID;
+    u64a domain_mask_adjusted = fdr->domainMask << 1;
+    u8 stride = fdr->stride;
+    const u8 *ft = (const u8 *)fdr + ROUNDUP_16(sizeof(struct FDR));
+    const u32 *confBase = (const u32 *)(ft + fdr->tabSize);
+    struct zone zones[ZONE_MAX];
+    assert(fdr->domain > 8 && fdr->domain < 16);
+
+    size_t numZone = prepareZones(a->buf, a->len,
+                                  a->buf_history + a->len_history,
+                                  a->start_offset, a->firstFloodDetect, zones);
+    assert(numZone <= ZONE_MAX);
+    m128 state = getInitState(fdr, a->len_history, ft, &zones[0]);
+
+    for (size_t curZone = 0; curZone < numZone; curZone++) {
+        struct zone *z = &zones[curZone];
+        dumpZoneInfo(z, curZone);
+
+        /* When a zone contains less data than is processed in an iteration
+         * of FDR_MAIN_LOOP(), we need to scan over some extra data.
+         *
+         * We have chosen to scan this extra data at the start of the
+         * iteration. The extra data is either data we have already scanned or
+         * garbage (if it is earlier than offset 0),
+         *
+         * As a result we need to shift the incoming state back so that it will
+         * properly line up with the data being scanned.
+         *
+         * We also need to forbid reporting any matches in the data being
+         * rescanned as they have already been reported (or are over garbage but
+         * later stages should also provide that safety guarantee).
+         */
+
+        u8 shift = z->shift;
+
+        state = variable_byte_shift_m128(state, shift);
+
+        state = or128(state, load128(zone_or_mask[shift]));
+
+        switch (stride) {
+        case 1:
+            FDR_MAIN_LOOP(z, state, get_conf_stride_1);
+            break;
+        case 2:
+            FDR_MAIN_LOOP(z, state, get_conf_stride_2);
+            break;
+        case 4:
+            FDR_MAIN_LOOP(z, state, get_conf_stride_4);
+            break;
+        default:
+            break;
+        }
+    }
+
+    return HWLM_SUCCESS;
+}
+
+#if defined(__AVX2__)
+#define ONLY_AVX2(func) func
+#else
+#define ONLY_AVX2(func) NULL
+#endif
+
+typedef hwlm_error_t (*FDRFUNCTYPE)(const struct FDR *fdr, const struct FDR_Runtime_Args *a);
+static const FDRFUNCTYPE funcs[] = {
+    fdr_engine_exec,
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks1_fast),
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks1_pck_fast),
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks1_fat),
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks1_pck_fat),
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks2_fat),
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks2_pck_fat),
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks3_fat),
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks3_pck_fat),
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks4_fat),
+    ONLY_AVX2(fdr_exec_teddy_avx2_msks4_pck_fat),
+    fdr_exec_teddy_msks1,
+    fdr_exec_teddy_msks1_pck,
+    fdr_exec_teddy_msks2,
+    fdr_exec_teddy_msks2_pck,
+    fdr_exec_teddy_msks3,
+    fdr_exec_teddy_msks3_pck,
+    fdr_exec_teddy_msks4,
+    fdr_exec_teddy_msks4_pck,
+};
 
 #define FAKE_HISTORY_SIZE 16
 static const u8 fake_history[FAKE_HISTORY_SIZE];
 
-hwlm_error_t fdrExec(const struct FDR *fdr, const u8 *buf, size_t len, size_t start,
-                     HWLMCallback cb, void *ctxt, hwlm_group_t groups) {
+hwlm_error_t fdrExec(const struct FDR *fdr, const u8 *buf, size_t len,
+                     size_t start, HWLMCallback cb, void *ctxt,
+                     hwlm_group_t groups) {
+    // We guarantee (for safezone construction) that it is safe to read 16
+    // bytes before the end of the history buffer.
+    const u8 *hbuf = fake_history + FAKE_HISTORY_SIZE;
 
     const struct FDR_Runtime_Args a = {
         buf,
         len,
-        fake_history,
+        hbuf,
         0,
-        fake_history, // nocase
+        hbuf, // nocase
         0,
         start,
         cb,
@@ -73,7 +829,7 @@ hwlm_error_t fdrExec(const struct FDR *fdr, const u8 *buf, size_t len, size_t st
 hwlm_error_t fdrExecStreaming(const struct FDR *fdr, const u8 *hbuf,
                               size_t hlen, const u8 *buf, size_t len,
                               size_t start, HWLMCallback cb, void *ctxt,
-                              hwlm_group_t groups, u8 * stream_state) {
+                              hwlm_group_t groups, u8 *stream_state) {
     struct FDR_Runtime_Args a = {
         buf,
         len,
@@ -86,9 +842,9 @@ hwlm_error_t fdrExecStreaming(const struct FDR *fdr, const u8 *hbuf,
         ctxt,
         &groups,
         nextFloodDetect(buf, len, FLOOD_BACKOFF_START),
-        hbuf ? CONF_LOADVAL_CALL_CAUTIOUS(hbuf + hlen - 8, hbuf, hbuf + hlen)
-             : (u64a)0
-
+        /* we are guaranteed to always have 16 initialised bytes at the end of
+         * the history buffer (they may be garbage). */
+        hbuf ? unaligned_load_u64a(hbuf + hlen - sizeof(u64a)) : (u64a)0
     };
     fdrUnpackState(fdr, &a, stream_state);
 
diff --git a/src/fdr/fdr.h b/src/fdr/fdr.h
index c70f9488..e0aa594f 100644
--- a/src/fdr/fdr.h
+++ b/src/fdr/fdr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -43,9 +43,6 @@ extern "C" {
 
 struct FDR;
 
-/** \brief Returns size in bytes of the given FDR engine. */
-size_t fdrSize(const struct FDR *fdr);
-
 /** \brief Returns non-zero if the contents of the stream state indicate that
  * there is active FDR history beyond the regularly used history. */
 u32 fdrStreamStateActive(const struct FDR *fdr, const u8 *stream_state);
diff --git a/src/fdr/fdr_autogen.py b/src/fdr/fdr_autogen.py
deleted file mode 100755
index 748d811f..00000000
--- a/src/fdr/fdr_autogen.py
+++ /dev/null
@@ -1,564 +0,0 @@
-#!/usr/bin/python
-
-# Copyright (c) 2015, Intel Corporation
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#     * Redistributions of source code must retain the above copyright notice,
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright
-#       notice, this list of conditions and the following disclaimer in the
-#       documentation and/or other materials provided with the distribution.
-#     * Neither the name of Intel Corporation nor the names of its contributors
-#       may be used to endorse or promote products derived from this software
-#       without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import sys
-from autogen_utils import *
-from base_autogen import *
-from string import Template
-
-class OrStep(Step):
-    def __init__(self, context, offset, width):
-        Step.__init__(self, context, offset)
-        s_var = self.gv("st%d" % offset)
-        if width < 128:
-            self.val = "s |= %s;" % s_var.name
-        else:
-            self.val = "s = or%d(s, %s);" % (width, s_var.name)
-
-class ShiftStateStep(Step):
-    def __init__(self, context, offset = 0, stride_used = 1):
-        Step.__init__(self, context, offset)
-        m = self.matcher
-        state = m.state_variable
-        shift_distance = -1 * stride_used * m.num_buckets
-        self.val = "%s = %s;" % (state.name, state.type.shift_expr(state.name, shift_distance))
-
-class BulkLoadStep(Step):
-    def __init__(self, context, offset, size, define_var = True, aligned = True):
-        Step.__init__(self, context, offset)
-        m = self.matcher
-        self.latency = 4
-        blt = m.bulk_load_type
-        if aligned:
-            init_string = blt.load_expr_data(self.offset, code = "aligned")
-        else:
-            init_string = blt.load_expr_data(self.offset)
-
-        var_name = "current_data_%d" % offset
-        if define_var:
-            lb_var = self.nv(blt, var_name)
-            self.val = lb_var.gen_initializer_stmt(init_string)
-        else:
-            lb_var = self.gv(var_name, reader = False, writer = True)
-            self.val = "%s = %s;" % (var_name, init_string)
-
-class ValueExtractStep(Step):
-    def __init__(self, context, offset, sub_load_cautious = False):
-        Step.__init__(self, context, offset)
-        m = self.matcher
-        self.latency = 2
-        dsb = m.datasize_bytes
-        modval = offset % dsb
-
-        if modval == dsb - 1:
-            # Case 1: reading more than one byte over the end of the bulk load
-
-            self.latency = 4
-            if sub_load_cautious:
-                code_string = "cautious_forward"
-            else:
-                code_string = "normal"
-            load_string = m.single_load_type.load_expr_data(self.offset, code_string)
-            temp_string = "(%s << %d)" % (load_string, m.reach_shift_adjust)
-        else:
-            # Case 2: reading a value that can be found entirely in the current register
-            if m.fdr2_force_naive_load:
-                load_string = m.single_load_type.load_expr_data(self.offset, "normal")
-                temp_string = "(%s << %d)" % (load_string, m.reach_shift_adjust)
-            else:
-                lb_var = self.gv("current_data_%d" % (offset - modval))
-                if modval == 0:
-                    # Case 2a: value is at LSB end of the register and must be left-
-                    # shifted into place if there is a "reach_shift_adjust" required
-                    temp_string = "(%s << %d)" % (lb_var.name, m.reach_shift_adjust)
-                else:
-                    # Case 2b: value is in the middle of the register and will be
-                    # right-shifted into place (adjusted by "reach_shift_adjust")
-                    temp_string = "(%s >> %d)" % (lb_var.name, modval*8 - m.reach_shift_adjust)
-
-
-        init_string = "(%s) & (domain_mask << %d)" % (temp_string, m.reach_shift_adjust)
-        v_var = self.nv(m.value_extract_type, "v%d" % offset)
-        self.val = v_var.gen_initializer_stmt(init_string)
-
-class TableLookupStep(Step):
-    def __init__(self, context, reach_multiplier, offset = 0):
-        Step.__init__(self, context, offset)
-        m = self.matcher
-        self.latency = 4
-        v_var = self.gv("v%d" % offset)
-        s_var = self.nv(m.state_type, "st%d" % offset)
-        init_string = "*(const %s *)(ft + %s*%dU)" % ( m.state_type.get_name(),
-                                                       v_var.name, reach_multiplier)
-        self.val = s_var.gen_initializer_stmt(init_string)
-
-class ShiftReachMaskStep(Step):
-    def __init__(self, context, offset):
-        Step.__init__(self, context, offset)
-        m = self.matcher
-        extr = m.extract_frequency
-        modval = offset % extr
-        s_var = self.gv("st%d" % offset, writer = True)
-        self.val = "%s = %s;" % (s_var.name, s_var.type.shift_expr(s_var.name, modval * m.num_buckets))
-
-class ConfExtractStep(Step):
-    def __init__(self, context, offset):
-        Step.__init__(self, context, offset)
-        m = self.matcher
-        if m.state_type.isSIMDOnIntel():
-            self.latency = 2
-        init_string = m.state_type.lowbit_extract_expr("s", m.extract_size)
-        extr_var = self.nv(m.extr_type, "extr%d" % offset)
-        self.val = extr_var.gen_initializer_stmt(init_string)
-
-class ConfAccumulateStep(Step):
-    def __init__(self, context, extract_offset, conf_offset, define_var = True):
-        Step.__init__(self, context, extract_offset)
-        m = self.matcher
-        extr_var = self.gv("extr%d" % extract_offset)
-        extr_var_cast = "((%s)%s)" % (m.conf_type.get_name(), extr_var.name)
-        if extract_offset == conf_offset:
-            # create conf_var as a straight copy of extr
-            if define_var:
-                conf_var = self.nv(m.conf_type, "conf%d" % conf_offset)
-                self.val = conf_var.gen_initializer_stmt(extr_var_cast)
-            else:
-                conf_var = self.gv("conf%d" % conf_offset, writer = True, reader = True)
-                self.val = "%s = %s;" % (conf_var.name, extr_var_cast)
-        else:
-            # shift extr_var and insert/OR it in conf_var
-            conf_var = self.gv("conf%d" % conf_offset, writer = True, reader = True)
-            shift_dist = (extract_offset - conf_offset) * m.num_buckets
-            self.val = "%s |= %s;" % (conf_var.name, m.conf_type.shift_expr(extr_var_cast, shift_dist))
-            self.latency = 2
-
-class ConfirmFlipStep(Step):
-    def __init__(self, context, offset):
-        Step.__init__(self, context, offset)
-        m = self.matcher
-        conf_var = self.gv("conf%d" % self.offset, writer = True)
-        self.val = "%s = %s;" % (conf_var.name,
-                       conf_var.type.flip_lowbits_expr(conf_var.name, self.matcher.confirm_frequency * m.num_buckets))
-
-class ConfirmStep(Step):
-    def __init__(self, context, offset, cautious = False):
-        Step.__init__(self, context, offset)
-        m = self.matcher
-        conf_var = self.gv("conf%d" % offset, writer = True)
-        self.val = m.produce_confirm_base(conf_var.name, conf_var.type.size, offset, cautious,
-                                          enable_confirmless = m.stride == 1, do_bailout = False)
-
-class M3(MatcherBase):
-    def produce_compile_call(self):
-        print "    { %d, %d, %d, %d, %s, %d, %d }," % (
-              self.id, self.state_width, self.num_buckets,
-              self.stride,
-              self.arch.target, self.conf_pull_back, self.conf_top_level_split)
-
-    def produce_main_loop(self, switch_variant = False):
-        stride_offsets = xrange(0, self.loop_bytes, self.stride)
-        stride_offsetSet = set(stride_offsets)
-        so_steps_last_block = []
-        sh = None
-        last_confirm = None
-        ctxt = CodeGenContext(self)
-
-        if switch_variant:
-            print "    ptr -= (iterBytes - dist);"
-            print "    { " # need an extra scope around switch variant to stop its globals escaping
-        else:
-            print "    if (doMainLoop) {"
-            print "    for (; ptr + LOOP_READ_AHEAD < buf + len; ptr += iterBytes) {"
-            print self.produce_flood_check()
-            print "        __builtin_prefetch(ptr + (iterBytes*4));"
-            print "        assert(((size_t)ptr % START_MOD) == 0);"
-
-
-        # just do globally for now
-        if switch_variant:
-            subsidiary_load_cautious = True
-            confirm_cautious = True
-        else:
-            subsidiary_load_cautious = False
-            confirm_cautious = False
-
-        if not self.fdr2_force_naive_load:
-            bulk_load_steps = [ off for off in range(self.loop_bytes)
-                                if off % self.datasize_bytes == 0 and
-                                   (set(range(off, off + self.datasize_bytes - 1)) & stride_offsetSet)]
-        else:
-            bulk_load_steps = []
-
-        confirm_steps = [ off for off in range(self.loop_bytes) if off % self.confirm_frequency == 0 ]
-
-        for off in bulk_load_steps:
-            lb_var = ctxt.new_var(None, self.bulk_load_type, "current_data_%d" % off)
-            print "        " + lb_var.gen_initializer_stmt()
-
-
-        for off in confirm_steps:
-            var_name = "conf%d" % off
-            conf_def_var = ctxt.new_var(None, self.conf_type, var_name)
-            if switch_variant:
-                init_string = "(%s)-1" % self.conf_type.get_name()
-            else:
-                init_string = ""
-            print "        " + conf_def_var.gen_initializer_stmt(init_string)
-
-        if switch_variant:
-            print "        switch(iterBytes - dist) {"
-            for i in range(0, self.loop_bytes):
-                print "            case %d:" % i
-
-                # init and poison conf; over-precise but harmless
-                conf_id = (i / self.confirm_frequency) * self.confirm_frequency
-                if i % self.confirm_frequency:
-                    conf_fixup_bits = self.conf_type.size - (self.num_buckets * (i % self.confirm_frequency))
-                    print "                conf%d >>= %d;" % (conf_id, conf_fixup_bits)
-                else:
-                    print "                conf%d = 0;" % conf_id
-
-                # init state
-                state_fixup = i % self.extract_frequency
-                state = self.state_variable
-                shift_distance = self.num_buckets * state_fixup
-                if state_fixup:
-                    print "                %s = %s;" % (state.name, state.type.shift_expr(state.name, shift_distance))
-                    if self.state_width < 128:
-                        print "                %s |= %s;" % (state.name, state.type.lowbit_mask(shift_distance))
-                    else:
-                        print "                %s = or%d(%s, %s);" % (state.name, self.state_width, state.name, state.type.lowbit_mask(shift_distance))
-
-                if not self.fdr2_force_naive_load:
-                    # init current_data (could poison it in some cases)
-                    load_mod = i % self.datasize_bytes
-                    load_offset = i - load_mod
-                    if load_mod:
-                        # not coming in on an even boundary means having to do a load var
-                        # actually, there are a bunch of things we can do on this bulk load
-                        # to avoid having to be 'cautious_backwards' but I'm not completely
-                        # sure they are good ideas
-                        init_string = self.bulk_load_type.load_expr_data(load_offset,
-                                                                         code = "cautious_backward")
-                        var_name = "current_data_%d" % load_offset
-                        lb_var = ctxt.get_var(None, var_name, reader = False, writer = True)
-                        print "                %s = %s;" % (lb_var.name, init_string)
-
-                print "                goto off%d;" % i
-            print "            case %d: goto skipSwitch;" % self.loop_bytes
-            print "        }"
-            print "        {"
-
-
-        for off in range(self.loop_bytes):
-            # X_mod is the offset we're up to relative to the last X operation
-            # X_offset is which of the last X operations matches this iteration
-
-            if (switch_variant):
-                LabelStep(ctxt, off)
-
-            if off in bulk_load_steps:
-                if not self.fdr2_force_naive_load:
-                    BulkLoadStep(ctxt, off, self.datasize, define_var = False, aligned = not switch_variant)
-
-            if off in stride_offsets:
-                if switch_variant:
-                    OpenScopeStep(ctxt, off)
-                ValueExtractStep(ctxt, off, sub_load_cautious = subsidiary_load_cautious)
-                TableLookupStep(ctxt, self.reach_mult, off)
-                if off % self.extract_frequency:
-                    ShiftReachMaskStep(ctxt, off)
-                so = OrStep(ctxt, off, self.state_width)
-                if switch_variant:
-                    CloseScopeStep(ctxt, off)
-                if sh != None:
-                    so.add_dependency(sh)
-                so_steps_last_block += [ so ]
-
-            extract_mod = off % self.extract_frequency
-            extract_offset = off - extract_mod
-            extract_ready = extract_mod == self.extract_frequency - 1
-            if extract_ready:
-                if switch_variant:
-                    OpenScopeStep(ctxt, off)
-                ex = ConfExtractStep(ctxt, extract_offset)
-                ConfAccumulateStep(ctxt, extract_offset, confirm_offset, define_var = False)
-                for so_step in so_steps_last_block:
-                    ex.add_dependency(so_step)
-                if switch_variant:
-                    CloseScopeStep(ctxt, off)
-                so_steps_last_block = []
-                sh = ShiftStateStep(ctxt, extract_offset, stride_used = self.extract_frequency)
-                sh.add_dependency(ex)
-
-            confirm_mod = off % self.confirm_frequency
-            confirm_offset = off - confirm_mod
-            confirm_ready = confirm_mod == self.confirm_frequency - 1
-            if confirm_ready:
-                cflip = ConfirmFlipStep(ctxt, confirm_offset)
-                cf = ConfirmStep(ctxt, confirm_offset, cautious = confirm_cautious )
-                if last_confirm:
-                    cf.add_dependency(last_confirm)
-                last_confirm = cf
-
-
-        if not switch_variant:
-            print ctxt.schedule([ last_confirm, sh ])
-        else:
-            print ctxt.dontschedule([ last_confirm, sh ])
-
-        if switch_variant:
-            print "skipSwitch:;"
-            print "    ptr += iterBytes;"
-        print "    }" # close extra scope around switch variant
-        print "    }"
-
-
-    def produce_init_state(self):
-        state = self.state_variable
-        s_type = self.state_type
-        shift_distance = -1 * self.num_buckets
-        shift_expr = "%s = %s" % (state.name, state.type.shift_expr(state.name, shift_distance))
-
-        s = Template("""
-    $TYPENAME s;
-    if (a->len_history) {
-        u32 tmp = 0;
-        if (a->start_offset == 0) {
-            tmp = a->buf_history[a->len_history - 1];
-            tmp |= (a->buf[0] << 8);
-        } else {
-            tmp = lv_u16(a->buf + a->start_offset - 1, a->buf, a->buf + a->len);
-        }
-        tmp &= fdr->domainMask;
-        s = *((const $TYPENAME *)ft + tmp);
-        $SHIFT_EXPR;
-    } else {
-        s = *(const $TYPENAME *)&fdr->start;
-    }
-""").substitute(TYPENAME = s_type.get_name(),
-                ZERO_EXPR = s_type.zero_expression(),
-                SHIFT_EXPR = shift_expr)
-        return s
-
-    def produce_code(self):
-
-        loop_read_behind = 0
-        loop_read_ahead = self.loop_bytes + 1
-
-        # we set up mask and shift stuff for extracting our masks from registers
-        #
-        # we have a choice as to whether to mask out the value early or
-        # extract the value (shift first) then mask it
-        #
-        # Intel has a free scaling factor from 1/2/4/8 so we want to combine
-        # the extra needed shift for SSE registers with the mask operation
-
-        ssb = self.state_type.size / 8 # state size in bytes
-
-        # Intel path
-        if ssb == 16:
-            # obscure corner - we don't have the room in the register to
-            # do this for all values so we don't. domain==16 is pretty
-            # bad anyhow, of course
-            self.reach_mult = 8
-        else:
-            self.reach_mult = ssb
-
-        shift_amts = { 1 : 0, 2 : 1, 4 : 2, 8 : 3, 16: 4 }
-        self.reach_shift_adjust = shift_amts[ ssb/self.reach_mult ]
-
-        print self.produce_header(visible = False)
-
-        print "// ",
-        print " Arch: " + self.arch.name,
-        print " State type: " + self.state_type.get_name(),
-        print " Num buckets: %d" % self.num_buckets,
-        print " Stride: %d" % self.stride
-
-        print self.produce_common_declarations()
-
-        print "    assert(fdr->domain > 8 && fdr->domain < 16);"
-        print
-        print "    u64a domain_mask = fdr->domainMask;"
-        print "    const u8 * ft = (const u8 *)fdr + ROUNDUP_16(sizeof(struct FDR));"
-        print "    const u32 * confBase = (const u32 *)(ft + fdr->tabSize);"
-        print self.produce_init_state()
-        print "    const size_t iterBytes = %d;" % self.loop_bytes
-        print "    const size_t START_MOD = %d;" % self.datasize_bytes
-        print "    const size_t LOOP_READ_AHEAD = %d;" % loop_read_ahead
-
-        print """
-    while (ptr < buf + len) {
-
-        u8 doMainLoop = 1;
-        size_t remaining = len - (ptr - buf);
-        size_t dist;
-        if (remaining <= iterBytes) {
-            dist = remaining; // once through the switch and we're done
-        } else if (remaining < 2 * iterBytes) {
-            // nibble some stuff off the front, skip the main loop,
-            // then come back here
-            dist = iterBytes;  // maybe could be cleverer
-        } else {
-            // now, we need to see if we can make it to a main loop iteration
-            // if so, we need to ensure that the main loop iteration is aligned
-            // to a START_MOD boundary and i >= 8 so we can read ptr + i - 8
-
-            // see if we can do it - if not, just switch the main loop off,
-            // eat iterBytes in cautious mode, and come back to this loop
-
-            const u8 * target = MAX(buf + 8, ptr);
-            target = ROUNDUP_PTR(target, START_MOD);
-            dist = target - ptr;
-            if (dist > iterBytes) {
-                doMainLoop = 0;
-                dist = iterBytes;
-            }
-        }
-"""
-        self.produce_main_loop(switch_variant = True)
-        self.produce_main_loop(switch_variant = False)
-        print """
-    }
-"""
-        print self.produce_footer()
-
-    def get_name(self):
-        return "fdr_exec_%s_s%d_w%d" % (self.arch.name, self.stride, self.state_width)
-
-    def __init__(self, state_width, stride,
-                 arch,
-                 table_state_width = None,
-                 num_buckets = 8,
-                 extract_frequency = None,
-                 confirm_frequency = None):
-
-        # First - set up the values that are fundamental to how this matcher will operate
-        self.arch = arch
-
-        # get the width of the state width on which we operate internally
-        if state_width not in [ 128 ]:
-            fail_out("Unknown state width: %d" % state_width)
-        self.state_width = state_width
-        self.state_type = getRequiredType(self.state_width)
-        self.state_variable = IntegerVariable("s", self.state_type)
-
-        table_state_width = state_width
-        self.table_state_width = state_width
-        self.table_state_type = getRequiredType(self.table_state_width)
-
-        # this is the load type required for domain [9:15] if we want to
-        # load it one at a time
-        self.single_load_type = IntegerType(16)
-
-        # stride is the frequency with which we make data-driven
-        # accesses to our reach table
-        if stride not in [ 1, 2, 4, 8]:
-            fail_out("Unsupported stride: %d" % stride)
-        if stride * num_buckets > state_width:
-            fail_out("Stride %d is too big for the number of buckets %d given state width %d\n" % (stride, num_buckets, state_width))
-        self.stride = stride
-
-        if num_buckets != 8:
-            fail_out("Unsupported number of buckets: %d" % num_buckets)
-        if state_width % num_buckets and state_width == 128:
-            fail_out("Bucket scheme requires bit-shifts on m128 (failing)")
-        self.num_buckets = num_buckets
-
-        # Second - set up derived or optimization values - these can be
-        # overridden by arguments that are passed in
-
-        self.datasize = 64
-        self.bulk_load_type = IntegerType(self.datasize)
-        self.datasize_bytes = self.datasize/8
-
-        self.value_extract_type = IntegerType(self.datasize)
-
-        self.fdr2_force_naive_load = False # disable everywhere for trunk
-
-        # extract frequency is how frequently (in bytes) we destructively shift
-        # our state value after having pulled out that many bytes into a
-        # confirm register (of one sort or another).
-        # none means a default value - datasize, our biggest easily available GPR
-        if extract_frequency is None:
-            extract_frequency = self.datasize_bytes
-        self.extract_frequency = extract_frequency
-        self.extract_size = self.extract_frequency*self.num_buckets
-        if extract_frequency < stride:
-            fail_out("Can't extract at extract frequency %d with stride %d" % (extract_frequency, stride))
-        if extract_frequency not in [ None, 1, 2, 4, 8, 16]:
-            fail_out("Weird extract frequency: %d" % extract_frequency)
-
-        if self.extract_size <= 32:
-            self.extr_type = IntegerType(32)
-        elif self.extract_size <= 64:
-            self.extr_type = IntegerType(64)
-        else:
-            fail_out("Implausible size %d required for confirm extract step" % size)
-
-        # extract_frequency is how often we pull out our state and place
-        # it somewhere in a lossless fashion
-        # confirm_frequency, on the other hand, is how frequently we
-        # take the state extracted by extract_frequency and cobble it
-        # together into a matching loop
-        # confirm_frequency must be a multiple of extract_frequency
-        # and must fit into a fast register; for now; we're going to
-        # stay in the GPR domain
-        if confirm_frequency is None:
-            confirm_frequency = self.extract_frequency
-        self.confirm_frequency = confirm_frequency
-        if confirm_frequency % self.extract_frequency:
-            fail_out("Confirm frequency %d must be evenly divisible by extract_frequency %d" % (confirm_frequency, self.extract_frequency))
-
-        self.conf_size = self.confirm_frequency * self.num_buckets
-        if self.conf_size <= 32:
-            self.conf_type = IntegerType(32)
-        elif self.conf_size <= 64:
-            self.conf_type = IntegerType(64)
-        else:
-            fail_out("Implausible size %d required for confirm accumulate step" % self.conf_size)
-
-        # how many bytes in flight at once
-        self.loop_bytes = 16
-
-        # confirm configuration
-
-        # how many entries in the top-level confirm table - 256 means
-        # complete split on the last character
-        self.conf_top_level_split = 256
-
-        # how much we 'pull back' in confirm - this is obviously related
-        # to the first level conf but we will keep two separate paramters
-        # for this to avoid the risk of conflating these
-        self.conf_pull_back = 1
-
-        if self.conf_pull_back > 0 and self.conf_top_level_split < 256:
-            fail_out("Pull back distance %d not supported by top level split %d" % (self.conf_pull_back, self.conf_top_level_split))
-
-        # minor stuff
-        self.default_body_indent = 8
diff --git a/src/fdr/fdr_compile.cpp b/src/fdr/fdr_compile.cpp
index ccf17626..0c4ef35d 100644
--- a/src/fdr/fdr_compile.cpp
+++ b/src/fdr/fdr_compile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -29,7 +29,7 @@
 /** \file
  * \brief FDR literal matcher: build API.
  */
-#include "fdr.h"
+
 #include "fdr_internal.h"
 #include "fdr_compile.h"
 #include "fdr_confirm.h"
@@ -187,9 +187,9 @@ aligned_unique_ptr<FDR> FDRCompiler::setupFDR(pair<u8 *, size_t> link) {
     /*  we are allowing domains 9 to 15 only */
     assert(eng.bits > 8 && eng.bits < 16);
     fdr->domain = eng.bits;
-    fdr->schemeWidthByte = eng.schemeWidth / 8;
     fdr->domainMask = (1 << eng.bits) - 1;
-    fdr->tabSize = (1 << eng.bits) * fdr->schemeWidthByte;
+    fdr->tabSize = (1 << eng.bits) * (eng.schemeWidth / 8);
+    fdr->stride = eng.stride;
 
     if (link.first) {
         fdr->link = verify_u32(ptr - fdr_base);
@@ -544,6 +544,7 @@ fdrBuildTableInternal(const vector<hwlmLiteral> &lits, bool make_small,
     // temporary hack for unit testing
     if (hint != HINT_INVALID) {
         des->bits = 9;
+        des->stride = 1;
     }
 
     FDRCompiler fc(lits, *des, make_small);
@@ -571,10 +572,9 @@ fdrBuildTableHinted(const vector<hwlmLiteral> &lits, bool make_small, u32 hint,
 
 #endif
 
-} // namespace ue2
-
-// FIXME: should be compile-time only
 size_t fdrSize(const FDR *fdr) {
     assert(fdr);
     return fdr->size;
 }
+
+} // namespace ue2
diff --git a/src/fdr/fdr_compile.h b/src/fdr/fdr_compile.h
index 73418568..c12e0071 100644
--- a/src/fdr/fdr_compile.h
+++ b/src/fdr/fdr_compile.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -61,6 +61,9 @@ fdrBuildTableHinted(const std::vector<hwlmLiteral> &lits, bool make_small,
 
 #endif
 
+/** \brief Returns size in bytes of the given FDR engine. */
+size_t fdrSize(const struct FDR *fdr);
+
 } // namespace ue2
 
 #endif
diff --git a/src/fdr/fdr_confirm_compile.cpp b/src/fdr/fdr_confirm_compile.cpp
index db236f31..08946a5f 100644
--- a/src/fdr/fdr_confirm_compile.cpp
+++ b/src/fdr/fdr_confirm_compile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,7 +26,6 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "fdr.h"
 #include "fdr_internal.h"
 #include "fdr_compile_internal.h"
 #include "fdr_confirm.h"
diff --git a/src/fdr/fdr_confirm_runtime.h b/src/fdr/fdr_confirm_runtime.h
index a77a8b89..9b1df593 100644
--- a/src/fdr/fdr_confirm_runtime.h
+++ b/src/fdr/fdr_confirm_runtime.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -36,144 +36,121 @@
 #include "util/bitutils.h"
 #include "util/compare.h"
 
-#define CONF_LOADVAL_CALL lv_u64a
-#define CONF_LOADVAL_CALL_CAUTIOUS lv_u64a_ce
-
 // this is ordinary confirmation function which runs through
 // the whole confirmation procedure
 static really_inline
-void confWithBit(const struct FDRConfirm * fdrc,
-                 const struct FDR_Runtime_Args * a,
-                 size_t i,
-                 CautionReason r,
-                 u32 pullBackAmount,
-                 hwlmcb_rv_t *control,
-                 u32 * last_match) {
+void confWithBit(const struct FDRConfirm *fdrc, const struct FDR_Runtime_Args *a,
+                 size_t i, u32 pullBackAmount, hwlmcb_rv_t *control,
+                 u32 *last_match, u64a conf_key) {
     assert(i < a->len);
     assert(ISALIGNED(fdrc));
 
     const u8 * buf = a->buf;
-    const size_t len = a->len;
-
-    CONF_TYPE v;
-    const u8 * confirm_loc = buf + i - pullBackAmount - 7;
-    if (likely(r == NOT_CAUTIOUS || confirm_loc >= buf)) {
-        v = CONF_LOADVAL_CALL(confirm_loc, buf, buf + len);
-    } else { // r == VECTORING, confirm_loc < buf
-        u64a histBytes = a->histBytes;
-        v = CONF_LOADVAL_CALL_CAUTIOUS(confirm_loc, buf, buf + len);
-        // stitch together v (which doesn't move) and history (which does)
-        u32 overhang = buf - confirm_loc;
-        histBytes >>= 64 - (overhang * 8);
-        v |= histBytes;
+    u32 c = CONF_HASH_CALL(conf_key, fdrc->andmsk, fdrc->mult,
+                           fdrc->nBitsOrSoleID);
+    u32 start = getConfirmLitIndex(fdrc)[c];
+    if (likely(!start)) {
+        return;
     }
 
-    u32 c = CONF_HASH_CALL(v, fdrc->andmsk, fdrc->mult, fdrc->nBitsOrSoleID);
-    u32 start = getConfirmLitIndex(fdrc)[c];
-    if (P0(start)) {
-        const struct LitInfo *l =
-            (const struct LitInfo *)((const u8 *)fdrc + start);
+    const struct LitInfo *li
+        = (const struct LitInfo *)((const u8 *)fdrc + start);
 
-        u8 oldNext; // initialized in loop
-        do {
-            assert(ISALIGNED(l));
+    u8 oldNext; // initialized in loop
+    do {
+        assert(ISALIGNED(li));
 
-            if (P0( (v & l->msk) != l->v)) {
+        if (unlikely((conf_key & li->msk) != li->v)) {
+            goto out;
+        }
+
+        if ((*last_match == li->id) && (li->flags & NoRepeat)) {
+            goto out;
+        }
+
+        const u8 *loc = buf + i - li->size + 1 - pullBackAmount;
+
+        u8 caseless = li->flags & Caseless;
+        if (loc < buf) {
+            u32 full_overhang = buf - loc;
+
+            const u8 *history = caseless ? a->buf_history_nocase
+                                         : a->buf_history;
+            size_t len_history = caseless ? a->len_history_nocase
+                                          : a->len_history;
+
+            // can't do a vectored confirm either if we don't have
+            // the bytes
+            if (full_overhang > len_history) {
                 goto out;
             }
 
-            if ((*last_match == l->id) && (l->flags & NoRepeat)) {
-                goto out;
+            // as for the regular case, no need to do a full confirm if
+            // we're a short literal
+            if (unlikely(li->size > sizeof(CONF_TYPE))) {
+                const u8 *s1 = li->s;
+                const u8 *s2 = s1 + full_overhang;
+                const u8 *loc1 = history + len_history - full_overhang;
+                const u8 *loc2 = buf;
+                size_t size1 = MIN(full_overhang, li->size - sizeof(CONF_TYPE));
+                size_t wind_size2_back = sizeof(CONF_TYPE) + full_overhang;
+                size_t size2 = wind_size2_back > li->size ?
+                    0 : li->size - wind_size2_back;
+
+                if (cmpForward(loc1, s1, size1, caseless)) {
+                    goto out;
+                }
+                if (cmpForward(loc2, s2, size2, caseless)) {
+                    goto out;
+                }
             }
+        } else { // NON-VECTORING PATH
 
-            const u8 * loc = buf + i - l->size + 1 - pullBackAmount;
+            // if string < conf_type we don't need regular string cmp
+            if (unlikely(li->size > sizeof(CONF_TYPE))) {
+                if (cmpForward(loc, li->s, li->size - sizeof(CONF_TYPE),
+                               caseless)) {
+                    goto out;
+                }
+            }
+        }
 
-            u8 caseless = l->flags & Caseless;
-            if (loc < buf) {
-                u32 full_overhang = buf - loc;
+        if (unlikely(!(li->groups & *control))) {
+            goto out;
+        }
 
-                const u8 * history = (caseless) ?
-                                      a->buf_history_nocase : a->buf_history;
-                size_t len_history = (caseless) ?
-                                      a->len_history_nocase : a->len_history;
-
-                // can't do a vectored confirm either if we don't have
-                // the bytes
+        if (unlikely(li->flags & ComplexConfirm)) {
+            const u8 *loc2 = buf + i - li->extended_size + 1 - pullBackAmount;
+            if (loc2 < buf) {
+                u32 full_overhang = buf - loc2;
+                size_t len_history = caseless ? a->len_history_nocase
+                                              : a->len_history;
                 if (full_overhang > len_history) {
                     goto out;
                 }
-
-                // as for the regular case, no need to do a full confirm if
-                // we're a short literal
-                if (unlikely(l->size > sizeof(CONF_TYPE))) {
-                    const u8 * s1 = l->s;
-                    const u8 * s2 = s1 + full_overhang;
-                    const u8 * loc1 = history + len_history - full_overhang;
-                    const u8 * loc2 = buf;
-                    size_t size1 = MIN(full_overhang,
-                                       l->size - sizeof(CONF_TYPE));
-                    size_t wind_size2_back = sizeof(CONF_TYPE) +
-                                             full_overhang;
-                    size_t size2 = wind_size2_back > l->size ?
-                                   0 : l->size - wind_size2_back;
-
-                    if (cmpForward(loc1, s1, size1, caseless)) {
-                        goto out;
-                    }
-                    if (cmpForward(loc2, s2, size2, caseless)) {
-                        goto out;
-                    }
-                }
-            } else { // NON-VECTORING PATH
-
-                // if string < conf_type we don't need regular string cmp
-                if (unlikely(l->size > sizeof(CONF_TYPE))) {
-                    if (cmpForward(loc, l->s, l->size - sizeof(CONF_TYPE), caseless)) {
-                        goto out;
-                    }
-                }
             }
+        }
 
-            if (P0(!(l->groups & *control))) {
-                goto out;
-            }
-
-            if (unlikely(l->flags & ComplexConfirm)) {
-                const u8 * loc2 = buf + i - l->extended_size + 1 - pullBackAmount;
-                if (loc2 < buf) {
-                    u32 full_overhang = buf - loc2;
-                    size_t len_history = (caseless) ?
-                                          a->len_history_nocase : a->len_history;
-                    if (full_overhang > len_history) {
-                        goto out;
-                    }
-                }
-            }
-
-            *last_match = l->id;
-            *control = a->cb(loc - buf, i, l->id, a->ctxt);
-out:
-            oldNext = l->next; // oldNext is either 0 or an 'adjust' value
-            l = (const struct LitInfo*)((const u8 *)l + oldNext + l->size);
-        } while (oldNext);
-    }
+        *last_match = li->id;
+        *control = a->cb(loc - buf, i, li->id, a->ctxt);
+    out:
+        oldNext = li->next; // oldNext is either 0 or an 'adjust' value
+        li = (const struct LitInfo *)((const u8 *)li + oldNext + li->size);
+    } while (oldNext);
 }
 
 // 'light-weight' confirmation function which is used by 1-mask Teddy;
 // in the 'confirmless' case it simply calls callback function,
 // otherwise it calls 'confWithBit' function for the full confirmation procedure
 static really_inline
-void confWithBit1(const struct FDRConfirm * fdrc,
-                  const struct FDR_Runtime_Args * a,
-                  size_t i,
-                  CautionReason r,
-                  hwlmcb_rv_t *control,
-                  u32 * last_match) {
+void confWithBit1(const struct FDRConfirm *fdrc,
+                  const struct FDR_Runtime_Args *a, size_t i,
+                  hwlmcb_rv_t *control, u32 *last_match, u64a conf_key) {
     assert(i < a->len);
     assert(ISALIGNED(fdrc));
 
     if (unlikely(fdrc->mult)) {
-        confWithBit(fdrc, a, i, r, 0, control, last_match);
+        confWithBit(fdrc, a, i, 0, control, last_match, conf_key);
         return;
     } else {
         u32 id = fdrc->nBitsOrSoleID;
@@ -190,12 +167,9 @@ void confWithBit1(const struct FDRConfirm * fdrc,
 // In the 'confirmless' case it makes fast 32-bit comparison,
 // otherwise it calls 'confWithBit' function for the full confirmation procedure
 static really_inline
-void confWithBitMany(const struct FDRConfirm * fdrc,
-                     const struct FDR_Runtime_Args * a,
-                     size_t i,
-                     CautionReason r,
-                     hwlmcb_rv_t *control,
-                     u32 * last_match) {
+void confWithBitMany(const struct FDRConfirm *fdrc,
+                     const struct FDR_Runtime_Args *a, size_t i, CautionReason r,
+                     hwlmcb_rv_t *control, u32 *last_match, u64a conf_key) {
     assert(i < a->len);
     assert(ISALIGNED(fdrc));
 
@@ -204,7 +178,7 @@ void confWithBitMany(const struct FDRConfirm * fdrc,
     }
 
     if (unlikely(fdrc->mult)) {
-        confWithBit(fdrc, a, i, r, 0, control, last_match);
+        confWithBit(fdrc, a, i, 0, control, last_match, conf_key);
         return;
     } else {
         const u32 id = fdrc->nBitsOrSoleID;
@@ -215,7 +189,7 @@ void confWithBitMany(const struct FDRConfirm * fdrc,
         }
 
         if (r == VECTORING && len > i - a->start_offset) {
-            if (len > (i + a->len_history)) {
+            if (len > i + a->len_history) {
                 return;
             }
 
diff --git a/src/fdr/fdr_dump.cpp b/src/fdr/fdr_dump.cpp
index 158170c2..7e794bb3 100644
--- a/src/fdr/fdr_dump.cpp
+++ b/src/fdr/fdr_dump.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -28,11 +28,11 @@
 
 #include "config.h"
 
-#include "fdr.h"
-#include "fdr_internal.h"
+#include "fdr_compile.h"
 #include "fdr_compile_internal.h"
 #include "fdr_dump.h"
 #include "fdr_engine_description.h"
+#include "fdr_internal.h"
 #include "teddy_engine_description.h"
 #include "ue2common.h"
 
@@ -68,8 +68,7 @@ void fdrPrintStats(const FDR *fdr, FILE *f) {
     }
 
     if (isTeddy) {
-        unique_ptr<TeddyEngineDescription> des =
-            getTeddyDescription(fdr->engineID);
+        auto des = getTeddyDescription(fdr->engineID);
         if (des) {
             fprintf(f, "    masks      %u\n", des->numMasks);
             fprintf(f, "    buckets    %u\n", des->getNumBuckets());
@@ -78,16 +77,8 @@ void fdrPrintStats(const FDR *fdr, FILE *f) {
             fprintf(f, "   <unknown engine>\n");
         }
     } else {
-        unique_ptr<FDREngineDescription> des =
-            getFdrDescription(fdr->engineID);
-        if (des) {
-            fprintf(f, "    domain     %u\n", des->bits);
-            fprintf(f, "    stride     %u\n", des->stride);
-            fprintf(f, "    buckets    %u\n", des->getNumBuckets());
-            fprintf(f, "    width      %u\n", des->schemeWidth);
-        } else {
-            fprintf(f, "   <unknown engine>\n");
-        }
+        fprintf(f, "    domain     %u\n", fdr->domain);
+        fprintf(f, "    stride     %u\n", fdr->stride);
     }
 
     fprintf(f, "    strings    ???\n");
diff --git a/src/fdr/fdr_engine_description.cpp b/src/fdr/fdr_engine_description.cpp
index 5d470c7e..5e923b08 100644
--- a/src/fdr/fdr_engine_description.cpp
+++ b/src/fdr/fdr_engine_description.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -42,13 +42,11 @@ using namespace std;
 
 namespace ue2 {
 
-#include "fdr_autogen_compiler.cpp"
-
 FDREngineDescription::FDREngineDescription(const FDREngineDef &def)
     : EngineDescription(def.id, targetByArchFeatures(def.cpu_features),
                         def.numBuckets, def.confirmPullBackDistance,
                         def.confirmTopLevelSplit),
-      schemeWidth(def.schemeWidth), stride(def.stride), bits(0) {}
+      schemeWidth(def.schemeWidth), stride(0), bits(0) {}
 
 u32 FDREngineDescription::getDefaultFloodSuffixLength() const {
     // rounding up, so that scheme width 32 and 6 buckets is 6 not 5!
@@ -56,6 +54,12 @@ u32 FDREngineDescription::getDefaultFloodSuffixLength() const {
     return ((getSchemeWidth() + getNumBuckets() - 1) / getNumBuckets()) + 1;
 }
 
+void getFdrDescriptions(vector<FDREngineDescription> *out) {
+    static const FDREngineDef def = {0, 128, 8, 0, 1, 256};
+    out->clear();
+    out->emplace_back(def);
+}
+
 static
 u32 findDesiredStride(size_t num_lits, size_t min_len, size_t min_len_count) {
     u32 desiredStride = 1; // always our safe fallback
@@ -108,32 +112,33 @@ unique_ptr<FDREngineDescription> chooseEngine(const target_t &target,
     FDREngineDescription *best = nullptr;
     u32 best_score = 0;
 
+    FDREngineDescription &eng = allDescs[0];
+
     for (u32 domain = 9; domain <= 15; domain++) {
-        for (size_t engineID = 0; engineID < allDescs.size(); engineID++) {
+        for (size_t stride = 1; stride <= 4; stride *= 2) {
             // to make sure that domains >=14 have stride 1 according to origin
-            if (domain > 13 && engineID > 0) {
+            if (domain > 13 && stride > 1) {
                 continue;
             }
-            FDREngineDescription &eng = allDescs[engineID];
             if (!eng.isValidOnTarget(target)) {
                 continue;
             }
-            if (msl < eng.stride) {
+            if (msl < stride) {
                 continue;
             }
 
             u32 score = 100;
 
-            score -= absdiff(desiredStride, eng.stride);
+            score -= absdiff(desiredStride, stride);
 
-            if (eng.stride <= desiredStride) {
-                score += eng.stride;
+            if (stride <= desiredStride) {
+                score += stride;
             }
 
             u32 effLits = vl.size(); /* * desiredStride;*/
             u32 ideal;
             if (effLits < eng.getNumBuckets()) {
-                if (eng.stride == 1) {
+                if (stride == 1) {
                     ideal = 8;
                 } else {
                     ideal = 10;
@@ -158,27 +163,28 @@ unique_ptr<FDREngineDescription> chooseEngine(const target_t &target,
                 ideal -= 2;
             }
 
-            if (eng.stride > 1) {
+            if (stride > 1) {
                 ideal++;
             }
 
             DEBUG_PRINTF("effLits %u\n", effLits);
 
             if (target.is_atom_class() && !make_small && effLits < 4000) {
-                /* Unless it is a very heavy case, we want to build smaller tables
-                 * on lightweight machines due to their small caches. */
+                /* Unless it is a very heavy case, we want to build smaller
+                 * tables on lightweight machines due to their small caches. */
                 ideal -= 2;
             }
 
             score -= absdiff(ideal, domain);
 
-            DEBUG_PRINTF("fdr %u: width=%u, bits=%u, buckets=%u, stride=%u "
+            DEBUG_PRINTF("fdr %u: width=%u, domain=%u, buckets=%u, stride=%zu "
                          "-> score=%u\n",
-                         eng.getID(), eng.schemeWidth, eng.bits,
-                         eng.getNumBuckets(), eng.stride, score);
+                         eng.getID(), eng.schemeWidth, domain,
+                         eng.getNumBuckets(), stride, score);
 
             if (!best || score > best_score) {
                 eng.bits = domain;
+                eng.stride = stride;
                 best = &eng;
                 best_score = score;
             }
diff --git a/src/fdr/fdr_engine_description.h b/src/fdr/fdr_engine_description.h
index 45f64ac0..d4e70d4b 100644
--- a/src/fdr/fdr_engine_description.h
+++ b/src/fdr/fdr_engine_description.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -42,7 +42,6 @@ struct FDREngineDef {
     u32 id;
     u32 schemeWidth;
     u32 numBuckets;
-    u32 stride;
     u64a cpu_features;
     u32 confirmPullBackDistance;
     u32 confirmTopLevelSplit;
@@ -73,7 +72,6 @@ chooseEngine(const target_t &target, const std::vector<hwlmLiteral> &vl,
              bool make_small);
 std::unique_ptr<FDREngineDescription> getFdrDescription(u32 engineID);
 void getFdrDescriptions(std::vector<FDREngineDescription> *out);
-
 } // namespace ue2
 
 #endif
diff --git a/src/fdr/fdr_internal.h b/src/fdr/fdr_internal.h
index 607e039c..cde13f6c 100644
--- a/src/fdr/fdr_internal.h
+++ b/src/fdr/fdr_internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -76,17 +76,17 @@ struct FDR {
      * structures (spillover strings and hash table) if we're a secondary
      * structure. */
     u32 link;
-    u8 domain; /* dynamic domain info */
-    u8 schemeWidthByte;  /* scheme width in bytes */
+    u8 stride; /* stride - how frequeuntly the data is consulted by the first
+                * stage matcher */
+    u8 domain; /* number of bits used to index into main FDR table. This value
+                * is used only of debugging/asserts. */
     u16 domainMask; /* pre-computed domain mask */
     u32 tabSize; /* pre-computed hashtable size in bytes */
-    u32 pad1;
+    u32 pad;
 
-    union {
-        u32 s_u32;
-        u64a s_u64a;
-        m128 s_m128;
-    } start;
+    m128 start; /* initial start state to use at offset 0. The state has been set
+                 * up based on the min length of buckets to reduce the need for
+                 * pointless confirms. */
 };
 
 /** \brief FDR runtime arguments.
diff --git a/src/fdr/fdr_loadval.h b/src/fdr/fdr_loadval.h
index 95e8981f..86c39c7f 100644
--- a/src/fdr/fdr_loadval.h
+++ b/src/fdr/fdr_loadval.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -29,188 +29,43 @@
 #ifndef FDR_LOADVAL_H
 #define FDR_LOADVAL_H
 
-#include "fdr_internal.h"
 #include "ue2common.h"
 #include "util/unaligned.h"
-#include "util/simd_utils.h"
 
-#define MAKE_LOADVAL(type, name) \
-    static really_inline type name (const u8 * ptr, UNUSED const u8 * lo, UNUSED const u8 * hi)
+#define MAKE_LOADVAL(type, name)                \
+    static really_inline                                                \
+    type name(const u8 *ptr, UNUSED const u8 *lo, UNUSED const u8 *hi)
 
-#define NORMAL_SAFE(type)            assert(ptr >= lo && (ptr + sizeof(type) - 1) < hi)
-#define ALIGNED_SAFE(type)           NORMAL_SAFE(type); assert(((size_t)ptr % sizeof(type)) == 0);
-// these ones need asserts to test the property that we're not handling dynamically
-#define CAUTIOUS_FORWARD_SAFE(type)  assert(ptr >= lo)
-#define CAUTIOUS_BACKWARD_SAFE(type) assert((ptr + sizeof(type) - 1) < hi)
+#define NORMAL_SAFE(type)                                               \
+    do {                                                                \
+        assert(ptr >= lo);                                              \
+        assert(ptr + sizeof(type) - 1 < hi);                            \
+    } while(0)
 
-#define CF_INDEX_CHECK                        (ptr + i < hi)
-#define CB_INDEX_CHECK     (lo <= ptr + i)
-#define CE_INDEX_CHECK     (lo <= ptr + i) && (ptr + i < hi)
-
-#define MAKE_LOOP(TYPE, COND, SHIFT_FIDDLE)                                    \
-    TYPE v = 0;                                                                \
-    for (TYPE i = 0; i < sizeof(TYPE); i++) {                                  \
-        if (COND) {                                                            \
-            v += (TYPE)ptr[i] << ((SHIFT_FIDDLE)*8);                           \
-        }                                                                      \
-    }                                                                          \
+#define MAKE_LOOP_CE(TYPE)                                              \
+    TYPE v = 0;                                                         \
+    for (TYPE i = 0; i < sizeof(TYPE); i++) {                           \
+        if ((lo <= ptr + i) && (ptr + i < hi)) {                        \
+            v += (TYPE)ptr[i] << (i*8);                                 \
+        }                                                               \
+    }                                                                   \
     return v;
 
-#define MAKE_LOOP_BE(TYPE, COND) \
-    MAKE_LOOP(TYPE, COND, sizeof(TYPE)-i-1)
-
-#define MAKE_LOOP_LE(TYPE, COND) \
-    MAKE_LOOP(TYPE, COND, i)
-
-
-#define MAKE_LOOP_BE_CF(TYPE) CAUTIOUS_FORWARD_SAFE(TYPE);  MAKE_LOOP_BE(TYPE, CF_INDEX_CHECK)
-#define MAKE_LOOP_BE_CB(TYPE) CAUTIOUS_BACKWARD_SAFE(TYPE); MAKE_LOOP_BE(TYPE, CB_INDEX_CHECK)
-#define MAKE_LOOP_BE_CE(TYPE)                               MAKE_LOOP_BE(TYPE, CE_INDEX_CHECK)
-#define MAKE_LOOP_LE_CF(TYPE) CAUTIOUS_FORWARD_SAFE(TYPE);  MAKE_LOOP_LE(TYPE, CF_INDEX_CHECK)
-#define MAKE_LOOP_LE_CB(TYPE) CAUTIOUS_BACKWARD_SAFE(TYPE); MAKE_LOOP_LE(TYPE, CB_INDEX_CHECK)
-#define MAKE_LOOP_LE_CE(TYPE)                               MAKE_LOOP_LE(TYPE, CE_INDEX_CHECK)
-
 // no suffix = normal (unaligned)
-// _a        = aligned
-// _cf       = cautious forwards, base is always in bounds, but may read over the end of the buffer (test against hi)
-// _cb       = cautious backwards, final byte is always in bounds, but may read over the start of the buffer (test against lo)
 // _ce       = cautious everywhere (in both directions); test against hi and lo
 
-// u8 loadvals
-MAKE_LOADVAL(u8, lv_u8) {
-    NORMAL_SAFE(u8);
-    return *ptr;
-}
-
-MAKE_LOADVAL(u8, lv_u8_cf) {
-    CAUTIOUS_FORWARD_SAFE(u8);
-    if (ptr < hi) {
-        return *ptr;
-    } else {
-        return 0;
-    }
-}
-
-MAKE_LOADVAL(u8, lv_u8_cb) {
-    CAUTIOUS_BACKWARD_SAFE(u8);
-    if (lo <= ptr) {
-        return *ptr;
-    } else {
-        return 0;
-    }
-}
-
-MAKE_LOADVAL(u8, lv_u8_ce) {
-    if ((lo <= ptr) && (ptr < hi)) {
-        return *ptr;
-    } else {
-        return 0;
-    }
-}
-
 MAKE_LOADVAL(u16, lv_u16) {
     NORMAL_SAFE(u16);
     return unaligned_load_u16(ptr);
 }
 
-MAKE_LOADVAL(u16, lv_u16_a) {
-    ALIGNED_SAFE(u16);
-    return *(const u16 *)ptr;
-}
-
-MAKE_LOADVAL(u32, lv_u32) {
-    NORMAL_SAFE(u32);
-    return unaligned_load_u32(ptr);
-}
-
-MAKE_LOADVAL(u32, lv_u32_a) {
-    ALIGNED_SAFE(u32);
-    return *(const u32 *)ptr;
-}
-
 MAKE_LOADVAL(u64a, lv_u64a) {
     NORMAL_SAFE(u32);
     return unaligned_load_u64a(ptr);
 }
 
-MAKE_LOADVAL(u64a, lv_u64a_a) {
-    ALIGNED_SAFE(u64a);
-    return *(const u64a *)ptr;
-}
+MAKE_LOADVAL(u16, lv_u16_ce) { MAKE_LOOP_CE(u16); }
 
-MAKE_LOADVAL(u16, lv_u16_cf) { MAKE_LOOP_LE_CF(u16); }
-MAKE_LOADVAL(u16, lv_u16_cb) { MAKE_LOOP_LE_CB(u16); }
-MAKE_LOADVAL(u16, lv_u16_ce) { MAKE_LOOP_LE_CE(u16); }
-
-MAKE_LOADVAL(u32, lv_u32_cf) { MAKE_LOOP_LE_CF(u32); }
-MAKE_LOADVAL(u32, lv_u32_cb) { MAKE_LOOP_LE_CB(u32); }
-MAKE_LOADVAL(u32, lv_u32_ce) { MAKE_LOOP_LE_CE(u32); }
-
-MAKE_LOADVAL(u64a, lv_u64a_cf) { MAKE_LOOP_LE_CF(u64a); }
-MAKE_LOADVAL(u64a, lv_u64a_cb) { MAKE_LOOP_LE_CB(u64a); }
-MAKE_LOADVAL(u64a, lv_u64a_ce) { MAKE_LOOP_LE_CE(u64a); }
-
-MAKE_LOADVAL(m128, lv_m128) {
-    NORMAL_SAFE(m128);
-    return loadu128(ptr);
-}
-
-MAKE_LOADVAL(m128, lv_m128_a) {
-    ALIGNED_SAFE(m128);
-    assert((size_t)ptr % sizeof(m128) == 0);
-    return *(const m128 *)ptr;
-}
-
-// m128 cases need to be manually created
-
-MAKE_LOADVAL(m128, lv_m128_cf) {
-    CAUTIOUS_FORWARD_SAFE(m128);
-    union {
-        u8 val8[16];
-        m128 val128;
-    } u;
-
-    for (u32 i = 0; i < 16; i++) {
-        if (ptr + i < hi) {
-            u.val8[i] = ptr[i];
-        } else {
-            u.val8[i] = 0;
-        }
-    }
-    return u.val128;
-}
-
-MAKE_LOADVAL(m128, lv_m128_cb) {
-    CAUTIOUS_BACKWARD_SAFE(m128);
-    union {
-        u8 val8[16];
-        m128 val128;
-    } u;
-
-    for (u32 i = 0; i < 16; i++) {
-        if (lo <= ptr + i) {
-            u.val8[i] = ptr[i];
-        } else {
-            u.val8[i] = 0;
-        }
-    }
-    return u.val128;
-}
-
-MAKE_LOADVAL(m128, lv_m128_ce) {
-    union {
-        u8 val8[16];
-        m128 val128;
-    } u;
-
-    for (u32 i = 0; i < 16; i++) {
-        if ((lo <= ptr + i) && (ptr + i < hi)) {
-            u.val8[i] = ptr[i];
-        } else {
-            u.val8[i] = 0;
-        }
-    }
-    return u.val128;
-}
+MAKE_LOADVAL(u64a, lv_u64a_ce) { MAKE_LOOP_CE(u64a); }
 
 #endif
diff --git a/src/fdr/fdr_streaming_compile.cpp b/src/fdr/fdr_streaming_compile.cpp
index 8f9d4728..34536eec 100644
--- a/src/fdr/fdr_streaming_compile.cpp
+++ b/src/fdr/fdr_streaming_compile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,7 +26,6 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "fdr.h"
 #include "fdr_internal.h"
 #include "fdr_streaming_internal.h"
 #include "fdr_compile_internal.h"
diff --git a/src/fdr/fdr_streaming_runtime.h b/src/fdr/fdr_streaming_runtime.h
index 07dacf9d..fa5843c5 100644
--- a/src/fdr/fdr_streaming_runtime.h
+++ b/src/fdr/fdr_streaming_runtime.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -32,6 +32,8 @@
 #include "fdr_streaming_internal.h"
 #include "util/partial_store.h"
 
+#include <string.h>
+
 static really_inline
 const struct FDRSTableHeader * getSHDR(const struct FDR * fdr) {
     const u8 * linkPtr = ((const u8 *)fdr) + fdr->link;
diff --git a/src/fdr/flood_compile.cpp b/src/fdr/flood_compile.cpp
index 321a3212..2c131788 100644
--- a/src/fdr/flood_compile.cpp
+++ b/src/fdr/flood_compile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,7 +26,6 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "fdr.h"
 #include "fdr_internal.h"
 #include "fdr_confirm.h"
 #include "fdr_compile_internal.h"
diff --git a/src/fdr/teddy.c b/src/fdr/teddy.c
index 11df9d69..08b761c0 100644
--- a/src/fdr/teddy.c
+++ b/src/fdr/teddy.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,11 +26,19 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "config.h"
+/** \file
+ * \brief Teddy literal matcher: SSSE3 engine runtime.
+ */
+
+#include "fdr_internal.h"
+#include "flood_runtime.h"
+#include "teddy.h"
+#include "teddy_internal.h"
+#include "teddy_runtime_common.h"
 #include "util/simd_utils.h"
 #include "util/simd_utils_ssse3.h"
 
-static const u8 ALIGN_DIRECTIVE p_mask_arr[17][32] = {
+const u8 ALIGN_DIRECTIVE p_mask_arr[17][32] = {
     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -67,178 +75,584 @@ static const u8 ALIGN_DIRECTIVE p_mask_arr[17][32] = {
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
 };
 
-// Note: p_mask is an output param that initialises a poison mask.
-UNUSED static really_inline
-m128 vectoredLoad128(m128 *p_mask, const u8 *ptr, const u8 *lo, const u8 *hi,
-                     const u8 *buf_history, size_t len_history,
-                     const u32 nMasks) {
-    union {
-        u8 val8[16];
-        m128 val128;
-    } u;
-    u.val128 = zeroes128();
+#ifdef ARCH_64_BIT
+#define CONFIRM_TEDDY(var, bucket, offset, reason, conf_fn)                 \
+do {                                                                        \
+    if (unlikely(isnonzero128(var))) {                                      \
+        u64a lo = movq(var);                                                \
+        u64a hi = movq(byteShiftRight128(var, 8));                          \
+        if (unlikely(lo)) {                                                 \
+            conf_fn(&lo, bucket, offset, confBase, reason, a, ptr,          \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(hi)) {                                                 \
+            conf_fn(&hi, bucket, offset + 8, confBase, reason, a, ptr,      \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+    }                                                                       \
+} while (0);
+#else
+#define CONFIRM_TEDDY(var, bucket, offset, reason, conf_fn)                 \
+do {                                                                        \
+    if (unlikely(isnonzero128(var))) {                                      \
+        u32 part1 = movd(var);                                              \
+        u32 part2 = movd(byteShiftRight128(var, 4));                        \
+        u32 part3 = movd(byteShiftRight128(var, 8));                        \
+        u32 part4 = movd(byteShiftRight128(var, 12));                       \
+        if (unlikely(part1)) {                                              \
+            conf_fn(&part1, bucket, offset, confBase, reason, a, ptr,       \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part2)) {                                              \
+            conf_fn(&part2, bucket, offset + 4, confBase, reason, a, ptr,   \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part3)) {                                              \
+            conf_fn(&part3, bucket, offset + 8, confBase, reason, a, ptr,   \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part4)) {                                              \
+            conf_fn(&part4, bucket, offset + 12, confBase, reason, a, ptr,  \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+    }                                                                       \
+} while (0);
+#endif
 
-    if (ptr >= lo) {
-        u32 avail = (u32)(hi - ptr);
-        if (avail >= 16) {
-            *p_mask = load128((const void*)(p_mask_arr[16] + 16));
-            return loadu128(ptr);
-        }
-        *p_mask = load128((const void*)(p_mask_arr[avail] + 16));
-        for (u32 i = 0; i < avail; i++) {
-            u.val8[i] = ptr[i];
-        }
-    } else {
-        u32 need = MIN((u32)(lo - ptr), MIN(len_history, nMasks - 1));
-        u32 start = (u32)(lo - ptr);
-        u32 i;
-        for (i = start - need; ptr + i < lo; i++) {
-            u.val8[i] = buf_history[len_history - (lo - (ptr + i))];
-        }
-        u32 end = MIN(16, (u32)(hi - ptr));
-        *p_mask = loadu128((const void*)(p_mask_arr[end - start] + 16 - start));
-        for (; i < end; i++) {
-            u.val8[i] = ptr[i];
-        }
+static really_inline
+m128 prep_conf_teddy_m1(const m128 *maskBase, m128 p_mask, m128 val) {
+    m128 mask = set16x8(0xf);
+    m128 lo = and128(val, mask);
+    m128 hi = and128(rshift2x64(val, 4), mask);
+    return and128(and128(pshufb(maskBase[0*2], lo),
+                         pshufb(maskBase[0*2+1], hi)), p_mask);
+}
+
+static really_inline
+m128 prep_conf_teddy_m2(const m128 *maskBase, m128 *old_1, m128 p_mask,
+                        m128 val) {
+    m128 mask = set16x8(0xf);
+    m128 lo = and128(val, mask);
+    m128 hi = and128(rshift2x64(val, 4), mask);
+    m128 r = prep_conf_teddy_m1(maskBase, p_mask, val);
+
+    m128 res_1 = and128(pshufb(maskBase[1*2], lo),
+                        pshufb(maskBase[1*2+1], hi));
+    m128 res_shifted_1 = palignr(res_1, *old_1, 16-1);
+    *old_1 = res_1;
+    return and128(and128(r, p_mask), res_shifted_1);
+}
+
+static really_inline
+m128 prep_conf_teddy_m3(const m128 *maskBase, m128 *old_1, m128 *old_2,
+                        m128 p_mask, m128 val) {
+    m128 mask = set16x8(0xf);
+    m128 lo = and128(val, mask);
+    m128 hi = and128(rshift2x64(val, 4), mask);
+    m128 r = prep_conf_teddy_m2(maskBase, old_1, p_mask, val);
+
+    m128 res_2 = and128(pshufb(maskBase[2*2], lo),
+                        pshufb(maskBase[2*2+1], hi));
+    m128 res_shifted_2 = palignr(res_2, *old_2, 16-2);
+    *old_2 = res_2;
+    return and128(r, res_shifted_2);
+}
+
+static really_inline
+m128 prep_conf_teddy_m4(const m128 *maskBase, m128 *old_1, m128 *old_2,
+                        m128 *old_3, m128 p_mask, m128 val) {
+    m128 mask = set16x8(0xf);
+    m128 lo = and128(val, mask);
+    m128 hi = and128(rshift2x64(val, 4), mask);
+    m128 r = prep_conf_teddy_m3(maskBase, old_1, old_2, p_mask, val);
+
+    m128 res_3 = and128(pshufb(maskBase[3*2], lo),
+                        pshufb(maskBase[3*2+1], hi));
+    m128 res_shifted_3 = palignr(res_3, *old_3, 16-3);
+    *old_3 = res_3;
+    return and128(r, res_shifted_3);
+}
+
+hwlm_error_t fdr_exec_teddy_msks1(const struct FDR *fdr,
+                                  const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 1);
+
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 1);
+        m128 r_0 = prep_conf_teddy_m1(maskBase, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit1_teddy);
+        ptr += 16;
     }
 
-    return u.val128;
-}
-
-
-#if defined(__AVX2__)
-
-UNUSED static really_inline
-m256 vectoredLoad2x128(m256 *p_mask, const u8 *ptr, const u8 *lo, const u8 *hi,
-                     const u8 *buf_history, size_t len_history,
-                     const u32 nMasks) {
-    m128 p_mask128;
-    m256 ret = set2x128(vectoredLoad128(&p_mask128, ptr, lo, hi, buf_history, len_history, nMasks));
-    *p_mask = set2x128(p_mask128);
-    return ret;
-}
-
-static const u8 ALIGN_AVX_DIRECTIVE p_mask_arr256[33][64] = {
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
-};
-
-
-UNUSED static really_inline
-m256 vectoredLoad256(m256 *p_mask, const u8 *ptr, const u8 *lo, const u8 *hi,
-                     const u8 *buf_history, size_t len_history) {
-    union {
-        u8 val8[32];
-        m256 val256;
-    } u;
-
-    if (ptr >= lo) {
-        u32 avail = (u32)(hi - ptr);
-        if (avail >= 32) {
-            *p_mask = load256((const void*)(p_mask_arr256[32] + 32));
-            return loadu256(ptr);
-        }
-        *p_mask = load256((const void*)(p_mask_arr256[avail] + 32));
-        for (u32 i = 0; i < avail; i++) {
-            u.val8[i] = ptr[i];
-        }
-    } else {
-        // need contains "how many chars to pull from history"
-        // calculate based on what we need, what we have in the buffer
-        // and only what we need to make primary confirm work
-        u32 start = (u32)(lo - ptr);
-        u32 i;
-        for (i = start; ptr + i < lo; i++) {
-            u.val8[i] = buf_history[len_history - (lo - (ptr + i))];
-        }
-        u32 end = MIN(32, (u32)(hi - ptr));
-        *p_mask = loadu256((const void*)(p_mask_arr256[end - start] + 32 - start));
-        for (; i < end; i++) {
-            u.val8[i] = ptr[i];
-        }
+    if (ptr + 16 < buf_end) {
+        m128 r_0 = prep_conf_teddy_m1(maskBase, ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit1_teddy);
+        ptr += 16;
     }
 
-    return u.val256;
+    for (; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m128 r_0 = prep_conf_teddy_m1(maskBase, ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit1_teddy);
+        m128 r_1 = prep_conf_teddy_m1(maskBase, ones128(), load128(ptr + 16));
+        CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit1_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 1);
+        m128 r_0 = prep_conf_teddy_m1(maskBase, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit1_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
 }
 
+hwlm_error_t fdr_exec_teddy_msks1_pck(const struct FDR *fdr,
+                                      const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
 
-#endif // __AVX2__
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 1);
 
-#define P0(cnd) unlikely(cnd)
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 1);
+        m128 r_0 = prep_conf_teddy_m1(maskBase, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
 
-#include "fdr.h"
-#include "fdr_internal.h"
-#include "flood_runtime.h"
+    if (ptr + 16 < buf_end) {
+        m128 r_0 = prep_conf_teddy_m1(maskBase, ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
 
-#include "fdr_confirm.h"
-#include "fdr_confirm_runtime.h"
+    for (; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m128 r_0 = prep_conf_teddy_m1(maskBase, ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit_teddy);
+        m128 r_1 = prep_conf_teddy_m1(maskBase, ones128(), load128(ptr + 16));
+        CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit_teddy);
+    }
 
-#include "fdr_loadval.h"
-#include "util/bitutils.h"
-#include "teddy_internal.h"
+    for (; ptr < buf_end; ptr += 16) {
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 1);
+        m128 r_0 = prep_conf_teddy_m1(maskBase, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
 
-#include "teddy_autogen.c"
+hwlm_error_t fdr_exec_teddy_msks2(const struct FDR *fdr,
+                                  const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 2);
+
+    m128 res_old_1 = ones128();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 2);
+        m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, ones128(),
+                                      load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    for (; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, ones128(),
+                                      load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+        m128 r_1 = prep_conf_teddy_m2(maskBase, &res_old_1, ones128(),
+                                      load128(ptr + 16));
+        CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 2);
+        m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_msks2_pck(const struct FDR *fdr,
+                                      const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 2);
+
+    m128 res_old_1 = ones128();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 2);
+        m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, ones128(),
+                                      load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    for (; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, ones128(),
+                                      load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit_teddy);
+        m128 r_1 = prep_conf_teddy_m2(maskBase, &res_old_1, ones128(),
+                                      load128(ptr + 16));
+        CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                   a->buf_history, a->len_history, 2);
+        m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_msks3(const struct FDR *fdr,
+                                  const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 3);
+
+    m128 res_old_1 = ones128();
+    m128 res_old_2 = ones128();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 3);
+        m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    for (; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+        m128 r_1 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      ones128(), load128(ptr + 16));
+        CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 3);
+        m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_msks3_pck(const struct FDR *fdr,
+                                      const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 3);
+
+    m128 res_old_1 = ones128();
+    m128 res_old_2 = ones128();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 3);
+        m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    for (; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit_teddy);
+        m128 r_1 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      ones128(), load128(ptr + 16));
+        CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 3);
+        m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                      p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_msks4(const struct FDR *fdr,
+                                  const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 4);
+
+    m128 res_old_1 = ones128();
+    m128 res_old_2 = ones128();
+    m128 res_old_3 = ones128();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 4);
+        m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    for (; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+        m128 r_1 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, ones128(), load128(ptr + 16));
+        CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 4);
+        m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_msks4_pck(const struct FDR *fdr,
+                                      const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 4);
+
+    m128 res_old_1 = ones128();
+    m128 res_old_2 = ones128();
+    m128 res_old_3 = ones128();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 4);
+        m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    for (; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, ones128(), load128(ptr));
+        CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit_teddy);
+        m128 r_1 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, ones128(), load128(ptr + 16));
+        CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m128 p_mask;
+        m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end,
+                                     a->buf_history, a->len_history, 4);
+        m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                      &res_old_3, p_mask, val_0);
+        CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
diff --git a/src/fdr/teddy.h b/src/fdr/teddy.h
new file mode 100644
index 00000000..f3902723
--- /dev/null
+++ b/src/fdr/teddy.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** \file
+ * \brief Teddy literal matcher: function declarations.
+ */
+
+#ifndef TEDDY_H_
+#define TEDDY_H_
+
+struct FDR; // forward declaration from fdr_internal.h
+struct FDR_Runtime_Args;
+
+hwlm_error_t fdr_exec_teddy_msks1(const struct FDR *fdr,
+                                  const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_msks1_pck(const struct FDR *fdr,
+                                      const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_msks2(const struct FDR *fdr,
+                                  const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_msks2_pck(const struct FDR *fdr,
+                                      const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_msks3(const struct FDR *fdr,
+                                  const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_msks3_pck(const struct FDR *fdr,
+                                      const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_msks4(const struct FDR *fdr,
+                                  const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_msks4_pck(const struct FDR *fdr,
+                                      const struct FDR_Runtime_Args *a);
+
+#if defined(__AVX2__)
+
+hwlm_error_t fdr_exec_teddy_avx2_msks1_fat(const struct FDR *fdr,
+                                           const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_avx2_msks1_pck_fat(const struct FDR *fdr,
+                                               const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_avx2_msks2_fat(const struct FDR *fdr,
+                                           const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_avx2_msks2_pck_fat(const struct FDR *fdr,
+                                               const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_avx2_msks3_fat(const struct FDR *fdr,
+                                           const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_avx2_msks3_pck_fat(const struct FDR *fdr,
+                                               const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_avx2_msks4_fat(const struct FDR *fdr,
+                                           const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_avx2_msks4_pck_fat(const struct FDR *fdr,
+                                               const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_avx2_msks1_fast(const struct FDR *fdr,
+                                            const struct FDR_Runtime_Args *a);
+
+hwlm_error_t fdr_exec_teddy_avx2_msks1_pck_fast(const struct FDR *fdr,
+                                                const struct FDR_Runtime_Args *a);
+
+#endif /* __AVX2__ */
+
+#endif /* TEDDY_H_ */
diff --git a/src/fdr/teddy_autogen.py b/src/fdr/teddy_autogen.py
deleted file mode 100755
index 21050110..00000000
--- a/src/fdr/teddy_autogen.py
+++ /dev/null
@@ -1,545 +0,0 @@
-#!/usr/bin/python
-
-# Copyright (c) 2015, Intel Corporation
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#     * Redistributions of source code must retain the above copyright notice,
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright
-#       notice, this list of conditions and the following disclaimer in the
-#       documentation and/or other materials provided with the distribution.
-#     * Neither the name of Intel Corporation nor the names of its contributors
-#       may be used to endorse or promote products derived from this software
-#       without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import sys
-from autogen_utils import *
-from base_autogen import *
-from string import Template
-
-class MT(MatcherBase):
-    def produce_confirm(self, iter, var_name, offset, bits, cautious = True):
-        if self.packed:
-            print self.produce_confirm_base(var_name, bits, iter*16 + offset, cautious, enable_confirmless = False, do_bailout = False)
-        else:
-            if self.num_masks == 1:
-                conf_func = "confWithBit1"
-            else:
-                conf_func = "confWithBitMany"
-
-            if cautious:
-                caution_string = "VECTORING"
-            else:
-                caution_string = "NOT_CAUTIOUS"
-
-            print "            if (P0(!!%s)) {" % var_name
-            print "                do  {"
-            if bits == 64:
-                print "                    bit = findAndClearLSB_64(&%s);" % (var_name)
-            else:
-                print "                    bit = findAndClearLSB_32(&%s);" % (var_name)
-            print "                    byte  = bit / %d + %d;" % (self.num_buckets, iter*16 + offset)
-            print "                    idx  = bit %% %d;" % self.num_buckets
-            print "                    cf = confBase[idx];"
-            print "                    fdrc = (const struct FDRConfirm *)((const u8 *)confBase + cf);"
-            print "                    if (!(fdrc->groups & *control))"
-            print "                        continue;"
-            print "                    %s(fdrc, a, ptr - buf + byte, %s, control, &last_match);" % (conf_func, caution_string)
-            print "                } while(P0(!!%s));" % var_name
-            print "                if (P0(controlVal == HWLM_TERMINATE_MATCHING)) {"
-            print "                    *a->groups = controlVal;"
-            print "                    return HWLM_TERMINATED;"
-            print "                }"
-            print "            }"
-
-    def produce_needed_temporaries(self, max_iterations):
-        print "        m128 p_mask;"
-        for iter in range(0, max_iterations):
-            print "        m128 val_%d;" % iter
-            print "        m128 val_%d_lo;" % iter
-            print "        m128 val_%d_hi;" % iter
-            for x in range(self.num_masks):
-                print "        m128 res_%d_%d;" % (iter, x)
-                if x != 0:
-                    print "        m128 res_shifted_%d_%d;" % (iter, x)
-            print "        m128 r_%d;" % iter
-            print "#ifdef ARCH_64_BIT"
-            print "            u64a r_%d_lopart;" % iter
-            print "            u64a r_%d_hipart;" % iter
-            print "#else"
-            print "            u32 r_%d_part1;" % iter
-            print "            u32 r_%d_part2;" % iter
-            print "            u32 r_%d_part3;" % iter
-            print "            u32 r_%d_part4;" % iter
-            print "#endif"
-
-    def produce_one_iteration_state_calc(self, iter, effective_num_iterations,
-                                         cautious, save_old):
-        if cautious:
-            print "        val_%d = vectoredLoad128(&p_mask, ptr + %d, buf, buf+len, a->buf_history, a->len_history, %d);" % (iter, iter*16, self.num_masks)
-        else:
-            print "        val_%d = load128(ptr + %d);" % (iter, iter*16)
-        print "        val_%d_lo = and128(val_%d, lomask);" % (iter, iter)
-        print "        val_%d_hi = rshift2x64(val_%d, 4);" % (iter, iter)
-        print "        val_%d_hi = and128(val_%d_hi, lomask);" % (iter, iter)
-        print
-        for x in range(self.num_masks):
-            print Template("""
-        res_${ITER}_${X} = and128(pshufb(maskBase[${X}*2]  , val_${ITER}_lo),
-                                  pshufb(maskBase[${X}*2+1], val_${ITER}_hi));""").substitute(ITER = iter, X = x)
-            if x != 0:
-                if iter == 0:
-                    print "        res_shifted_%d_%d = palignr(res_%d_%d, res_old_%d, 16-%d);" % (iter, x,   iter, x,         x,   x)
-                else:
-                    print "        res_shifted_%d_%d = palignr(res_%d_%d, res_%d_%d, 16-%d);" % (iter, x,    iter, x, iter-1, x,   x)
-            if x != 0 and iter == effective_num_iterations - 1 and save_old:
-                print "        res_old_%d = res_%d_%d;" % (x, iter, x)
-        print
-        if cautious:
-            print "        r_%d = and128(res_%d_0, p_mask);" % (iter, iter)
-        else:
-            print "        r_%d = res_%d_0;" % (iter, iter)
-        for x in range(1, self.num_masks):
-            print "        r_%d = and128(r_%d, res_shifted_%d_%d);" % (iter, iter, iter, x)
-        print
-
-    def produce_one_iteration_confirm(self, iter, confirmCautious):
-        setup64 = [ (0, "r_%d_lopart" % iter, "movq(r_%d)" % iter),
-                    (8, "r_%d_hipart" % iter, "movq(byteShiftRight128(r_%d, 8))" % iter) ]
-
-        setup32 = [ (0, "r_%d_part1" % iter, "movd(r_%d)" % iter),
-                    (4, "r_%d_part2" % iter, "movd(byteShiftRight128(r_%d, 4))" % iter),
-                    (8, "r_%d_part3" % iter, "movd(byteShiftRight128(r_%d, 8))" % iter),
-                    (12, "r_%d_part4" % iter, "movd(byteShiftRight128(r_%d, 12))" % iter) ]
-
-        print "        if (P0(isnonzero128(r_%d))) {" % (iter)
-        print "#ifdef ARCH_64_BIT"
-        for (off, val, init) in setup64:
-            print "            %s = %s;" % (val, init)
-        for (off, val, init) in setup64:
-            self.produce_confirm(iter, val, off, 64, cautious = confirmCautious)
-        print "#else"
-        for (off, val, init) in setup32:
-            print "            %s = %s;" % (val, init)
-        for (off, val, init) in setup32:
-            self.produce_confirm(iter, val, off, 32, cautious = confirmCautious)
-        print "#endif"
-        print "        }"
-
-    def produce_one_iteration(self, iter, effective_num_iterations, cautious = False,
-                              confirmCautious = True, save_old = True):
-        self.produce_one_iteration_state_calc(iter, effective_num_iterations, cautious, save_old)
-        self.produce_one_iteration_confirm(iter, confirmCautious)
-
-    def produce_code(self):
-        print self.produce_header(visible = True, header_only = False)
-        print self.produce_common_declarations()
-        print
-
-        self.produce_needed_temporaries(self.num_iterations)
-        print
-
-        print "    const struct Teddy * teddy = (const struct Teddy *)fdr;"
-        print "    const m128 * maskBase = (const m128 *)((const u8 *)fdr + sizeof(struct Teddy));"
-        print "    const u32 * confBase = (const u32 *)((const u8 *)teddy + sizeof(struct Teddy) + (%d*32));" % self.num_masks
-        print "    const u8 * mainStart = ROUNDUP_PTR(ptr, 16);"
-        print "    const size_t iterBytes = %d;" % (self.num_iterations * 16)
-
-        print '    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\\n",' \
-                                ' buf, len, a->start_offset);'
-        print '    DEBUG_PRINTF("derive: ptr: %p mainstart %p\\n", ptr,' \
-                                ' mainStart);'
-
-        for x in range(self.num_masks):
-            if (x != 0):
-                print "    m128 res_old_%d = ones128();" % x
-        print "    m128 lomask = set16x8(0xf);"
-
-        print "    if (ptr < mainStart) {"
-        print "         ptr = mainStart - 16;"
-        self.produce_one_iteration(0, 1, cautious = True, confirmCautious = True, save_old = True)
-        print "         ptr += 16;"
-        print "    }"
-
-        print "    if (ptr + 16 < buf + len) {"
-        self.produce_one_iteration(0, 1, cautious = False, confirmCautious = True, save_old = True)
-        print "         ptr += 16;"
-        print "    }"
-
-        print "    for ( ; ptr + iterBytes <= buf + len; ptr += iterBytes) {"
-        print "        __builtin_prefetch(ptr + (iterBytes*4));"
-        print self.produce_flood_check()
-
-        for iter in range(self.num_iterations):
-            self.produce_one_iteration(iter, self.num_iterations, cautious = False, confirmCautious = False)
-
-        print "    }"
-
-        print "    for (; ptr < buf + len; ptr += 16) {"
-        self.produce_one_iteration(0, 1, cautious = True, confirmCautious = True, save_old = True)
-        print "    }"
-
-        print self.produce_footer()
-
-    def produce_compile_call(self):
-        packed_str = { False : "false", True : "true"}[self.packed]
-        print "        { %d, %s, %d, %d, %s, %d, %d }," % (
-            self.id, self.arch.target, self.num_masks, self.num_buckets, packed_str,
-            self.conf_pull_back, self.conf_top_level_split)
-
-    def get_name(self):
-        if self.packed:
-            pck_string = "_pck"
-        else:
-            pck_string = ""
-
-        if self.num_buckets == 16:
-            type_string = "_fat"
-        else:
-            type_string = ""
-
-        return "fdr_exec_teddy_%s_msks%d%s%s" % (self.arch.name, self.num_masks, pck_string, type_string)
-
-    def __init__(self, arch, packed = False, num_masks = 1, num_buckets = 8):
-        self.arch = arch
-        self.packed = packed
-        self.num_masks = num_masks
-        self.num_buckets = num_buckets
-        self.num_iterations = 2
-
-        if packed:
-            self.conf_top_level_split = 32
-        else:
-            self.conf_top_level_split = 1
-        self.conf_pull_back = 0
-
-class MTFat(MT):
-    def produce_needed_temporaries(self, max_iterations):
-        print "        m256 p_mask;"
-        for iter in range(0, max_iterations):
-            print "        m256 val_%d;" % iter
-            print "        m256 val_%d_lo;" % iter
-            print "        m256 val_%d_hi;" % iter
-            for x in range(self.num_masks):
-                print "        m256 res_%d_%d;" % (iter, x)
-                if x != 0:
-                    print "        m256 res_shifted_%d_%d;" % (iter, x)
-            print "        m256 r_%d;" % iter
-            print "#ifdef ARCH_64_BIT"
-            print "            u64a r_%d_part1;" % iter
-            print "            u64a r_%d_part2;" % iter
-            print "            u64a r_%d_part3;" % iter
-            print "            u64a r_%d_part4;" % iter
-            print "#else"
-            print "            u32 r_%d_part1;" % iter
-            print "            u32 r_%d_part2;" % iter
-            print "            u32 r_%d_part3;" % iter
-            print "            u32 r_%d_part4;" % iter
-            print "            u32 r_%d_part5;" % iter
-            print "            u32 r_%d_part6;" % iter
-            print "            u32 r_%d_part7;" % iter
-            print "            u32 r_%d_part8;" % iter
-            print "#endif"
-
-    def produce_code(self):
-        print self.produce_header(visible = True, header_only = False)
-        print self.produce_common_declarations()
-        print
-
-        self.produce_needed_temporaries(self.num_iterations)
-        print
-
-        print "    const struct Teddy * teddy = (const struct Teddy *)fdr;"
-        print "    const m256 * maskBase = (const m256 *)((const u8 *)fdr + sizeof(struct Teddy));"
-        print "    const u32 * confBase = (const u32 *)((const u8 *)teddy + sizeof(struct Teddy) + (%d*32*2));" % self.num_masks
-        print "    const u8 * mainStart = ROUNDUP_PTR(ptr, 16);"
-        print "    const size_t iterBytes = %d;" % (self.num_iterations * 16)
-
-        print '    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\\n",' \
-                                ' buf, len, a->start_offset);'
-        print '    DEBUG_PRINTF("derive: ptr: %p mainstart %p\\n", ptr,' \
-                                ' mainStart);'
-
-        for x in range(self.num_masks):
-            if (x != 0):
-                print "    m256 res_old_%d = ones256();" % x
-        print "    m256 lomask = set32x8(0xf);"
-
-        print "    if (ptr < mainStart) {"
-        print "         ptr = mainStart - 16;"
-        self.produce_one_iteration(0, 1, cautious = True, confirmCautious = True, save_old = True)
-        print "         ptr += 16;"
-        print "    }"
-
-        print "    if (ptr + 16 < buf + len) {"
-        self.produce_one_iteration(0, 1, cautious = False, confirmCautious = True, save_old = True)
-        print "         ptr += 16;"
-        print "    }"
-
-        print "    for ( ; ptr + iterBytes <= buf + len; ptr += iterBytes) {"
-        print "        __builtin_prefetch(ptr + (iterBytes*4));"
-        print self.produce_flood_check()
-
-        for iter in range(self.num_iterations):
-            self.produce_one_iteration(iter, self.num_iterations, False, confirmCautious = False)
-
-        print "    }"
-
-        print "    for (; ptr < buf + len; ptr += 16) {"
-        self.produce_one_iteration(0, 1, cautious = True, confirmCautious = True, save_old = True)
-        print "    }"
-
-        print self.produce_footer()
-
-    def produce_one_iteration_state_calc(self, iter, effective_num_iterations,
-                                         cautious, save_old):
-        if cautious:
-            print "        val_%d = vectoredLoad2x128(&p_mask, ptr + %d, buf, buf+len, a->buf_history, a->len_history, %d);" % (iter, iter*16, self.num_masks)
-        else:
-            print "        val_%d = load2x128(ptr + %d);" % (iter, iter*16)
-        print "        val_%d_lo = and256(val_%d, lomask);" % (iter, iter)
-        print "        val_%d_hi = rshift4x64(val_%d, 4);" % (iter, iter)
-        print "        val_%d_hi = and256(val_%d_hi, lomask);" % (iter, iter)
-        print
-        for x in range(self.num_masks):
-            print Template("""
-        res_${ITER}_${X} = and256(vpshufb(maskBase[${X}*2]  , val_${ITER}_lo),
-                                  vpshufb(maskBase[${X}*2+1], val_${ITER}_hi));""").substitute(ITER = iter, X = x)
-            if x != 0:
-                if iter == 0:
-                    print "        res_shifted_%d_%d = vpalignr(res_%d_%d, res_old_%d, 16-%d);" % (iter, x,   iter, x,         x,   x)
-                else:
-                    print "        res_shifted_%d_%d = vpalignr(res_%d_%d, res_%d_%d, 16-%d);" % (iter, x,    iter, x, iter-1, x,   x)
-            if x != 0 and iter == effective_num_iterations - 1 and save_old:
-                print "        res_old_%d = res_%d_%d;" % (x, iter, x)
-        print
-        if cautious:
-            print "        r_%d = and256(res_%d_0, p_mask);" % (iter, iter)
-        else:
-            print "        r_%d = res_%d_0;" % (iter, iter)
-        for x in range(1, self.num_masks):
-            print "        r_%d = and256(r_%d, res_shifted_%d_%d);" % (iter, iter, iter, x)
-        print
-
-    def produce_one_iteration_confirm(self, iter, confirmCautious):
-        setup64 = [ (0, "r_%d_part1" % iter, "extractlow64from256(r)"),
-                    (4, "r_%d_part2" % iter, "extract64from256(r, 1);\n            r = interleave256hi(r_%d, r_swap)" % (iter)),
-                    (8, "r_%d_part3" % iter, "extractlow64from256(r)"),
-                    (12, "r_%d_part4" % iter, "extract64from256(r, 1)") ]
-
-        setup32 = [ (0, "r_%d_part1" % iter, "extractlow32from256(r)"),
-                    (2, "r_%d_part2" % iter, "extract32from256(r, 1)"),
-                    (4, "r_%d_part3" % iter, "extract32from256(r, 2)"),
-                    (6, "r_%d_part4" % iter, "extract32from256(r, 3);\n            r = interleave256hi(r_%d, r_swap)" % (iter)),
-                    (8, "r_%d_part5" % iter, "extractlow32from256(r)"),
-                    (10, "r_%d_part6" % iter, "extract32from256(r, 1)"),
-                    (12, "r_%d_part7" % iter, "extract32from256(r, 2)"),
-                    (14, "r_%d_part8" % iter, "extract32from256(r, 3)") ]
-
-        print "        if (P0(isnonzero256(r_%d))) {" % (iter)
-        print "            m256 r_swap = swap128in256(r_%d);" % (iter)
-        print "            m256 r = interleave256lo(r_%d, r_swap);" % (iter)
-        print "#ifdef ARCH_64_BIT"
-        for (off, val, init) in setup64:
-            print "            %s = %s;" % (val, init)
-
-        for (off, val, init) in setup64:
-            self.produce_confirm(iter, val, off, 64, cautious = confirmCautious)
-        print "#else"
-        for (off, val, init) in setup32:
-            print "            %s = %s;" % (val, init)
-
-        for (off, val, init) in setup32:
-            self.produce_confirm(iter, val, off, 32, cautious = confirmCautious)
-        print "#endif"
-        print "        }"
-
-class MTFast(MatcherBase):
-
-    def produce_confirm(self, cautious):
-        if cautious:
-            cautious_str = "VECTORING"
-        else:
-            cautious_str = "NOT_CAUTIOUS"
-
-        print "            for (u32 i = 0; i < arrCnt; i++) {"
-        print "                byte = bitArr[i] / 8;"
-        if self.packed:
-            conf_split_mask = IntegerType(32).constant_to_string(
-                                self.conf_top_level_split - 1)
-            print "                bitRem  = bitArr[i] % 8;"
-            print "                confSplit = *(ptr+byte) & 0x1f;"
-            print "                idx = confSplit * %d + bitRem;" % self.num_buckets
-            print "                cf = confBase[idx];"
-            print "                if (!cf)"
-            print "                    continue;"
-            print "                fdrc = (const struct FDRConfirm *)((const u8 *)confBase + cf);"
-            print "                if (!(fdrc->groups & *control))"
-            print "                    continue;"
-            print "                confWithBit(fdrc, a, ptr - buf + byte, %s, 0, control, &last_match);" % cautious_str
-        else:
-            print "                cf = confBase[bitArr[i] % 8];"
-            print "                fdrc = (const struct FDRConfirm *)((const u8 *)confBase + cf);"
-            print "                confWithBit1(fdrc, a, ptr - buf + byte, %s, control, &last_match);" % cautious_str
-        print "                if (P0(controlVal == HWLM_TERMINATE_MATCHING)) {"
-        print "                    *a->groups = controlVal;"
-        print "                    return HWLM_TERMINATED;"
-        print "                }"
-        print "            }"
-
-    def produce_needed_temporaries(self, max_iterations):
-        print "        u32 arrCnt;"
-        print "        u16 bitArr[512];"
-        print "        m256 p_mask;"
-        print "        m256 val_0;"
-        print "        m256 val_0_lo;"
-        print "        m256 val_0_hi;"
-        print "        m256 res_0;"
-        print "        m256 res_1;"
-        print "        m128 lo_part;"
-        print "        m128 hi_part;"
-        print "#ifdef ARCH_64_BIT"
-        print "        u64a r_0_part;"
-        print "#else"
-        print "        u32 r_0_part;"
-        print "#endif"
-
-    def produce_bit_scan(self, offset, bits):
-        print "                while (P0(!!r_0_part)) {"
-        if bits == 64:
-            print "                    bitArr[arrCnt++] = (u16)findAndClearLSB_64(&r_0_part) + 64 * %d;" % (offset)
-        else:
-            print "                    bitArr[arrCnt++] = (u16)findAndClearLSB_32(&r_0_part) + 32 * %d;" % (offset)
-        print "                }"
-
-    def produce_bit_check_128(self, var_name, offset):
-        print "            if (P0(isnonzero128(%s))) {" % (var_name)
-        print "#ifdef ARCH_64_BIT"
-        print "                r_0_part = movq(%s);" % (var_name)
-        self.produce_bit_scan(offset, 64)
-        print "                r_0_part = movq(byteShiftRight128(%s, 8));" % (var_name)
-        self.produce_bit_scan(offset + 1, 64)
-        print "#else"
-        print "                r_0_part = movd(%s);" % (var_name)
-        self.produce_bit_scan(offset * 2, 32)
-        for step in range(1, 4):
-            print "                r_0_part = movd(byteShiftRight128(%s, %d));" % (var_name, step * 4)
-            self.produce_bit_scan(offset * 2 + step, 32)
-        print "#endif"
-        print "            }"
-
-    def produce_bit_check_256(self, iter, single_iter, cautious):
-        print "        if (P0(isnonzero256(res_%d))) {" % (iter)
-        if single_iter:
-            print "            arrCnt = 0;"
-        print "            lo_part = cast256to128(res_%d);" % (iter)
-        print "            hi_part = cast256to128(swap128in256(res_%d));" % (iter)
-        self.produce_bit_check_128("lo_part", iter * 4)
-        self.produce_bit_check_128("hi_part", iter * 4 + 2)
-        if single_iter:
-            self.produce_confirm(cautious)
-        print "        }"
-
-    def produce_one_iteration_state_calc(self, iter, cautious):
-        if cautious:
-            print "        val_0 = vectoredLoad256(&p_mask, ptr + %d, buf+a->start_offset, buf+len, a->buf_history, a->len_history);" % (iter * 32)
-        else:
-            print "        val_0 = load256(ptr + %d);" % (iter * 32)
-        print "        val_0_lo = and256(val_0, lomask);"
-        print "        val_0_hi = rshift4x64(val_0, 4);"
-        print "        val_0_hi = and256(val_0_hi, lomask);"
-        print "        res_%d = and256(vpshufb(maskLo  , val_0_lo), vpshufb(maskHi, val_0_hi));" % (iter)
-        if cautious:
-            print "        res_%d = and256(res_%d, p_mask);" % (iter, iter)
-
-    def produce_code(self):
-        print self.produce_header(visible = True, header_only = False)
-        print self.produce_common_declarations()
-        print
-
-        self.produce_needed_temporaries(self.num_iterations)
-
-        print "    const struct Teddy * teddy = (const struct Teddy *)fdr;"
-        print "    const m128 * maskBase = (const m128 *)((const u8 *)fdr + sizeof(struct Teddy));"
-        print "    const m256 maskLo = set2x128(maskBase[0]);"
-        print "    const m256 maskHi = set2x128(maskBase[1]);"
-        print "    const u32 * confBase = (const u32 *)((const u8 *)teddy + sizeof(struct Teddy) + 32);"
-        print "    const u8 * mainStart = ROUNDUP_PTR(ptr, 32);"
-        print "    const size_t iterBytes = %d;" % (self.num_iterations * 32)
-
-        print '    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\\n",' \
-                                ' buf, len, a->start_offset);'
-        print '    DEBUG_PRINTF("derive: ptr: %p mainstart %p\\n", ptr,' \
-                                ' mainStart);'
-        print "    const m256 lomask = set32x8(0xf);"
-
-        print "    if (ptr < mainStart) {"
-        print "        ptr = mainStart - 32;"
-        self.produce_one_iteration_state_calc(iter = 0, cautious = True)
-        self.produce_bit_check_256(iter = 0, single_iter = True, cautious = True)
-        print "        ptr += 32;"
-        print "    }"
-
-        print "    if (ptr + 32 < buf + len) {"
-        self.produce_one_iteration_state_calc(iter = 0, cautious = False)
-        self.produce_bit_check_256(iter = 0, single_iter = True, cautious = True)
-        print "        ptr += 32;"
-        print "    }"
-        print "    for ( ; ptr + iterBytes <= buf + len; ptr += iterBytes) {"
-        print "        __builtin_prefetch(ptr + (iterBytes*4));"
-        print self.produce_flood_check()
-        for iter in range (0, self.num_iterations):
-            self.produce_one_iteration_state_calc(iter = iter, cautious = False)
-        print "        arrCnt = 0;"
-        for iter in range (0, self.num_iterations):
-            self.produce_bit_check_256(iter = iter, single_iter = False, cautious = False)
-        self.produce_confirm(cautious = False)
-        print "    }"
-
-        print "    for (; ptr < buf + len; ptr += 32) {"
-        self.produce_one_iteration_state_calc(iter = 0, cautious = True)
-        self.produce_bit_check_256(iter = 0, single_iter = True, cautious = True)
-        print "    }"
-
-        print self.produce_footer()
-
-    def get_name(self):
-        if self.packed:
-            pck_string = "_pck"
-        else:
-            pck_string = ""
-        return "fdr_exec_teddy_%s_msks%d%s_fast" % (self.arch.name, self.num_masks, pck_string)
-
-    def produce_compile_call(self):
-        packed_str = { False : "false", True : "true"}[self.packed]
-        print "        { %d, %s, %d, %d, %s, %d, %d }," % (
-            self.id, self.arch.target, self.num_masks, self.num_buckets, packed_str,
-            self.conf_pull_back, self.conf_top_level_split)
-
-    def __init__(self, arch, packed = False):
-        self.arch = arch
-        self.packed = packed
-        self.num_masks = 1
-        self.num_buckets = 8
-        self.num_iterations = 2
-
-        self.conf_top_level_split = 1
-        self.conf_pull_back = 0
-        if packed:
-            self.conf_top_level_split = 32
-        else:
-            self.conf_top_level_split = 1
-        self.conf_pull_back = 0
diff --git a/src/fdr/teddy_avx2.c b/src/fdr/teddy_avx2.c
new file mode 100644
index 00000000..33dd8a30
--- /dev/null
+++ b/src/fdr/teddy_avx2.c
@@ -0,0 +1,1110 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** \file
+ * \brief Teddy literal matcher: AVX2 engine runtime.
+ */
+
+#include "fdr_internal.h"
+#include "flood_runtime.h"
+#include "teddy.h"
+#include "teddy_internal.h"
+#include "teddy_runtime_common.h"
+#include "util/simd_utils.h"
+#include "util/simd_utils_ssse3.h"
+
+#if defined(__AVX2__)
+
+static const u8 ALIGN_AVX_DIRECTIVE p_mask_arr256[33][64] = {
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
+};
+
+#ifdef ARCH_64_BIT
+#define CONFIRM_FAT_TEDDY(var, bucket, offset, reason, conf_fn)             \
+do {                                                                        \
+    if (unlikely(isnonzero256(var))) {                                      \
+        m256 swap = swap128in256(var);                                      \
+        m256 r = interleave256lo(var, swap);                                \
+        u64a part1 = extractlow64from256(r);                                \
+        u64a part2 = extract64from256(r, 1);                                \
+        r = interleave256hi(var, swap);                                     \
+        u64a part3 = extractlow64from256(r);                                \
+        u64a part4 = extract64from256(r, 1);                                \
+        if (unlikely(part1)) {                                              \
+            conf_fn(&part1, bucket, offset, confBase, reason, a, ptr,       \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part2)) {                                              \
+            conf_fn(&part2, bucket, offset + 4, confBase, reason, a, ptr,   \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part3)) {                                              \
+            conf_fn(&part3, bucket, offset + 8, confBase, reason, a, ptr,   \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part4)) {                                              \
+            conf_fn(&part4, bucket, offset + 12, confBase, reason, a, ptr,  \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+    }                                                                       \
+} while (0);
+#else
+#define CONFIRM_FAT_TEDDY(var, bucket, offset, reason, conf_fn)             \
+do {                                                                        \
+    if (unlikely(isnonzero256(var))) {                                      \
+        m256 swap = swap128in256(var);                                      \
+        m256 r = interleave256lo(var, swap);                                \
+        u32 part1 = extractlow32from256(r);                                 \
+        u32 part2 = extract32from256(r, 1);                                 \
+        u32 part3 = extract32from256(r, 2);                                 \
+        u32 part4 = extract32from256(r, 3);                                 \
+        r = interleave256hi(var, swap);                                     \
+        u32 part5 = extractlow32from256(r);                                 \
+        u32 part6 = extract32from256(r, 1);                                 \
+        u32 part7 = extract32from256(r, 2);                                 \
+        u32 part8 = extract32from256(r, 3);                                 \
+        if (unlikely(part1)) {                                              \
+            conf_fn(&part1, bucket, offset, confBase, reason, a, ptr,       \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part2)) {                                              \
+            conf_fn(&part2, bucket, offset + 2, confBase, reason, a, ptr,   \
+                    control, &last_match);                                  \
+        }                                                                   \
+        if (unlikely(part3)) {                                              \
+            conf_fn(&part3, bucket, offset + 4, confBase, reason, a, ptr,   \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part4)) {                                              \
+            conf_fn(&part4, bucket, offset + 6, confBase, reason, a, ptr,   \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part5)) {                                              \
+            conf_fn(&part5, bucket, offset + 8, confBase, reason, a, ptr,   \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part6)) {                                              \
+            conf_fn(&part6, bucket, offset + 10, confBase, reason, a, ptr,  \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part7)) {                                              \
+            conf_fn(&part7, bucket, offset + 12, confBase, reason, a, ptr,  \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+        if (unlikely(part8)) {                                              \
+            conf_fn(&part8, bucket, offset + 14, confBase, reason, a, ptr,  \
+                    control, &last_match);                                  \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+    }                                                                       \
+} while (0);
+#endif
+
+#define CONFIRM_FAST_TEDDY(var, offset, reason, conf_fn)                    \
+do {                                                                        \
+    if (unlikely(isnonzero256(var))) {                                      \
+        u32 arrCnt = 0;                                                     \
+        m128 lo = cast256to128(var);                                        \
+        m128 hi = cast256to128(swap128in256(var));                          \
+        bit_array_fast_teddy(lo, bitArr, &arrCnt, offset);                  \
+        bit_array_fast_teddy(hi, bitArr, &arrCnt, offset + 2);              \
+        for (u32 i = 0; i < arrCnt; i++) {                                  \
+            conf_fn(bitArr[i], confBase, reason, a, ptr, control,           \
+                    &last_match);                                           \
+            CHECK_HWLM_TERMINATE_MATCHING;                                  \
+        }                                                                   \
+    }                                                                       \
+} while (0);
+
+static really_inline
+m256 vectoredLoad2x128(m256 *p_mask, const u8 *ptr, const u8 *lo, const u8 *hi,
+                       const u8 *buf_history, size_t len_history,
+                       const u32 nMasks) {
+    m128 p_mask128;
+    m256 ret = set2x128(vectoredLoad128(&p_mask128, ptr, lo, hi, buf_history,
+                                        len_history, nMasks));
+    *p_mask = set2x128(p_mask128);
+    return ret;
+}
+
+/*
+ * \brief Copy a block of [0,31] bytes efficiently.
+ *
+ * This function is a workaround intended to stop some compilers from
+ * synthesizing a memcpy function call out of the copy of a small number of
+ * bytes that we do in vectoredLoad128.
+ */
+static really_inline
+void copyRuntBlock256(u8 *dst, const u8 *src, size_t len) {
+    switch (len) {
+    case 0:
+        break;
+    case 1:
+        *dst = *src;
+        break;
+    case 2:
+        unaligned_store_u16(dst, unaligned_load_u16(src));
+        break;
+    case 3:
+        unaligned_store_u16(dst, unaligned_load_u16(src));
+        dst[2] = src[2];
+        break;
+    case 4:
+        unaligned_store_u32(dst, unaligned_load_u32(src));
+        break;
+    case 5:
+    case 6:
+    case 7:
+        /* Perform copy with two overlapping 4-byte chunks. */
+        unaligned_store_u32(dst + len - 4, unaligned_load_u32(src + len - 4));
+        unaligned_store_u32(dst, unaligned_load_u32(src));
+        break;
+    case 8:
+        unaligned_store_u64a(dst, unaligned_load_u64a(src));
+        break;
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+        /* Perform copy with two overlapping 8-byte chunks. */
+        unaligned_store_u64a(dst + len - 8, unaligned_load_u64a(src + len - 8));
+        unaligned_store_u64a(dst, unaligned_load_u64a(src));
+        break;
+    case 16:
+        storeu128(dst, loadu128(src));
+        break;
+    default:
+        /* Perform copy with two overlapping 16-byte chunks. */
+        assert(len < 32);
+        storeu128(dst + len - 16, loadu128(src + len - 16));
+        storeu128(dst, loadu128(src));
+        break;
+    }
+}
+
+static really_inline
+m256 vectoredLoad256(m256 *p_mask, const u8 *ptr, const u8 *lo, const u8 *hi,
+                     const u8 *buf_history, size_t len_history) {
+    union {
+        u8 val8[32];
+        m256 val256;
+    } u;
+
+    uintptr_t copy_start;
+    uintptr_t copy_len;
+
+    if (ptr >= lo) {
+        uintptr_t avail = (uintptr_t)(hi - ptr);
+        if (avail >= 32) {
+            *p_mask = load256(p_mask_arr256[32] + 32);
+            return loadu256(ptr);
+        }
+        *p_mask = load256(p_mask_arr256[avail] + 32);
+        copy_start = 0;
+        copy_len = avail;
+    } else {
+        // need contains "how many chars to pull from history"
+        // calculate based on what we need, what we have in the buffer
+        // and only what we need to make primary confirm work
+        uintptr_t start = (uintptr_t)(lo - ptr);
+        uintptr_t i;
+        for (i = start; ptr + i < lo; i++) {
+            u.val8[i] = buf_history[len_history - (lo - (ptr + i))];
+        }
+        uintptr_t end = MIN(32, (uintptr_t)(hi - ptr));
+        *p_mask = loadu256(p_mask_arr256[end - start] + 32 - start);
+        copy_start = i;
+        copy_len = end - i;
+    }
+
+    // Runt block from the buffer.
+    copyRuntBlock256(&u.val8[copy_start], &ptr[copy_start], copy_len);
+
+    return u.val256;
+}
+
+static really_inline
+void do_confWithBit1_fast_teddy(u16 bits, const u32 *confBase,
+                                CautionReason reason,
+                                const struct FDR_Runtime_Args *a,
+                                const u8 *ptr, hwlmcb_rv_t *control,
+                                u32 *last_match) {
+    u32 byte = bits / 8;
+    u32 cf = confBase[bits % 8];
+    const struct FDRConfirm *fdrc = (const struct FDRConfirm *)
+                                    ((const u8 *)confBase + cf);
+    u64a confVal = getConfVal(a, ptr, byte, reason);
+    confWithBit1(fdrc, a, ptr - a->buf + byte, control, last_match, confVal);
+}
+
+static really_inline
+void do_confWithBit_fast_teddy(u16 bits, const u32 *confBase,
+                               CautionReason reason,
+                               const struct FDR_Runtime_Args *a, const u8 *ptr,
+                               hwlmcb_rv_t *control, u32 *last_match) {
+    u32 byte = bits / 8;
+    u32 bitRem = bits % 8;
+    u32 confSplit = *(ptr+byte) & 0x1f;
+    u32 idx = confSplit * 8 + bitRem;
+    u32 cf = confBase[idx];
+    if (!cf) {
+        return;
+    }
+    const struct FDRConfirm *fdrc = (const struct FDRConfirm *)
+                                    ((const u8 *)confBase + cf);
+    if (!(fdrc->groups & *control)) {
+        return;
+    }
+    u64a confVal = getConfVal(a, ptr, byte, reason);
+    confWithBit(fdrc, a, ptr - a->buf + byte, 0, control, last_match, confVal);
+}
+
+static really_inline
+void bit_array_fast_teddy(m128 var, u16 *bitArr, u32 *arrCnt, u32 offset) {
+    if (unlikely(isnonzero128(var))) {
+#ifdef ARCH_64_BIT
+        u64a part_0 = movq(var);
+        while (unlikely(part_0)) {
+            bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_0) +
+                                    64 * (offset);
+            *arrCnt += 1;
+        }
+        u64a part_1 = movq(byteShiftRight128(var, 8));
+        while (unlikely(part_1)) {
+            bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_1) +
+                                    64 * (offset + 1);
+            *arrCnt += 1;
+        }
+#else
+        u32 part_0 = movd(var);
+        while (unlikely(part_0)) {
+            bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_0) +
+                                    32 * (offset * 2);
+            *arrCnt += 1;
+        }
+        u32 part_1 = movd(byteShiftRight128(var, 4));
+        while (unlikely(part_1)) {
+            bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_1) +
+                                    32 * (offset * 2 + 1);
+            *arrCnt += 1;
+        }
+        u32 part_2 = movd(byteShiftRight128(var, 8));
+        while (unlikely(part_2)) {
+            bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_2) +
+                                    32 * (offset * 2 + 2);
+            *arrCnt += 1;
+        }
+        u32 part_3 = movd(byteShiftRight128(var, 12));
+        while (unlikely(part_3)) {
+            bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_3) +
+                                    32 * (offset * 2 + 3);
+            *arrCnt += 1;
+        }
+#endif
+    }
+}
+
+static really_inline
+m256 prep_conf_fat_teddy_m1(const m256 *maskBase, m256 p_mask, m256 val) {
+    m256 mask = set32x8(0xf);
+    m256 lo = and256(val, mask);
+    m256 hi = and256(rshift4x64(val, 4), mask);
+    return and256(and256(vpshufb(maskBase[0*2], lo),
+                         vpshufb(maskBase[0*2+1], hi)), p_mask);
+}
+
+static really_inline
+m256 prep_conf_fat_teddy_m2(const m256 *maskBase, m256 *old_1, m256 p_mask,
+                            m256 val) {
+    m256 mask = set32x8(0xf);
+    m256 lo = and256(val, mask);
+    m256 hi = and256(rshift4x64(val, 4), mask);
+    m256 r = prep_conf_fat_teddy_m1(maskBase, p_mask, val);
+
+    m256 res_1 = and256(vpshufb(maskBase[1*2], lo),
+                        vpshufb(maskBase[1*2+1], hi));
+    m256 res_shifted_1 = vpalignr(res_1, *old_1, 16-1);
+    *old_1 = res_1;
+    return and256(and256(r, p_mask), res_shifted_1);
+}
+
+static really_inline
+m256 prep_conf_fat_teddy_m3(const m256 *maskBase, m256 *old_1, m256 *old_2,
+                            m256 p_mask, m256 val) {
+    m256 mask = set32x8(0xf);
+    m256 lo = and256(val, mask);
+    m256 hi = and256(rshift4x64(val, 4), mask);
+    m256 r = prep_conf_fat_teddy_m2(maskBase, old_1, p_mask, val);
+
+    m256 res_2 = and256(vpshufb(maskBase[2*2], lo),
+                        vpshufb(maskBase[2*2+1], hi));
+    m256 res_shifted_2 = vpalignr(res_2, *old_2, 16-2);
+    *old_2 = res_2;
+    return and256(r, res_shifted_2);
+}
+
+static really_inline
+m256 prep_conf_fat_teddy_m4(const m256 *maskBase, m256 *old_1, m256 *old_2,
+                            m256 *old_3, m256 p_mask, m256 val) {
+    m256 mask = set32x8(0xf);
+    m256 lo = and256(val, mask);
+    m256 hi = and256(rshift4x64(val, 4), mask);
+    m256 r = prep_conf_fat_teddy_m3(maskBase, old_1, old_2, p_mask, val);
+
+    m256 res_3 = and256(vpshufb(maskBase[3*2], lo),
+                        vpshufb(maskBase[3*2+1], hi));
+    m256 res_shifted_3 = vpalignr(res_3, *old_3, 16-3);
+    *old_3 = res_3;
+    return and256(r, res_shifted_3);
+}
+
+static really_inline
+m256 prep_conf_fast_teddy_m1(m256 val, m256 mask, m256 maskLo, m256 maskHi,
+                             m256 p_mask) {
+    m256 lo = and256(val, mask);
+    m256 hi = and256(rshift4x64(val, 4), mask);
+    m256 res = and256(vpshufb(maskLo, lo), vpshufb(maskHi, hi));
+    return and256(res, p_mask);
+}
+
+static really_inline
+const m256 * getMaskBase_avx2(const struct Teddy *teddy) {
+    return (const m256 *)((const u8 *)teddy + sizeof(struct Teddy));
+}
+
+static really_inline
+const u32 * getConfBase_avx2(const struct Teddy *teddy, u8 numMask) {
+    return (const u32 *)((const u8 *)teddy + sizeof(struct Teddy) +
+                         (numMask*32*2));
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks1_fat(const struct FDR *fdr,
+                                           const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m256 *maskBase = getMaskBase_avx2(teddy);
+    const u32 *confBase = getConfBase_avx2(teddy, 1);
+
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 1);
+        m256 r_0 = prep_conf_fat_teddy_m1(maskBase, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit1_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m256 r_0 = prep_conf_fat_teddy_m1(maskBase, ones256(), load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit1_teddy);
+        ptr += 16;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m256 r_0 = prep_conf_fat_teddy_m1(maskBase, ones256(), load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit1_teddy);
+        m256 r_1 = prep_conf_fat_teddy_m1(maskBase, ones256(),
+                                          load2x128(ptr + 16));
+        CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit1_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 1);
+        m256 r_0 = prep_conf_fat_teddy_m1(maskBase, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit1_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks1_pck_fat(const struct FDR *fdr,
+                                               const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m256 *maskBase = getMaskBase_avx2(teddy);
+    const u32 *confBase = getConfBase_avx2(teddy, 1);
+
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 1);
+        m256 r_0 = prep_conf_fat_teddy_m1(maskBase, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m256 r_0 = prep_conf_fat_teddy_m1(maskBase, ones256(), load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m256 r_0 = prep_conf_fat_teddy_m1(maskBase, ones256(), load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit_teddy);
+        m256 r_1 = prep_conf_fat_teddy_m1(maskBase, ones256(),
+                                          load2x128(ptr + 16));
+        CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 1);
+        m256 r_0 = prep_conf_fat_teddy_m1(maskBase, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks2_fat(const struct FDR *fdr,
+                                           const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m256 *maskBase = getMaskBase_avx2(teddy);
+    const u32 *confBase = getConfBase_avx2(teddy, 2);
+
+    m256 res_old_1 = ones256();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 2);
+        m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, ones256(),
+                                          load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, ones256(),
+                                          load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+        m256 r_1 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, ones256(),
+                                          load2x128(ptr + 16));
+        CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 2);
+        m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks2_pck_fat(const struct FDR *fdr,
+                                               const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m256 *maskBase = getMaskBase_avx2(teddy);
+    const u32 *confBase = getConfBase_avx2(teddy, 2);
+
+    m256 res_old_1 = ones256();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 2);
+        m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, ones256(),
+                                          load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+         ptr += 16;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, ones256(),
+                                          load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit_teddy);
+        m256 r_1 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, ones256(),
+                                          load2x128(ptr + 16));
+        CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 2);
+        m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks3_fat(const struct FDR *fdr,
+                                           const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m256 *maskBase = getMaskBase_avx2(teddy);
+    const u32 *confBase = getConfBase_avx2(teddy, 3);
+
+    m256 res_old_1 = ones256();
+    m256 res_old_2 = ones256();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 3);
+        m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          ones256(), load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          ones256(), load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+        m256 r_1 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          ones256(), load2x128(ptr + 16));
+        CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 3);
+        m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks3_pck_fat(const struct FDR *fdr,
+                                               const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m256 *maskBase = getMaskBase_avx2(teddy);
+    const u32 *confBase = getConfBase_avx2(teddy, 3);
+
+    m256 res_old_1 = ones256();
+    m256 res_old_2 = ones256();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 3);
+        m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          ones256(), load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          ones256(), load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit_teddy);
+        m256 r_1 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          ones256(), load2x128(ptr + 16));
+        CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 3);
+        m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2,
+                                          p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks4_fat(const struct FDR *fdr,
+                                           const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m256 *maskBase = getMaskBase_avx2(teddy);
+    const u32 *confBase = getConfBase_avx2(teddy, 4);
+
+    m256 res_old_1 = ones256();
+    m256 res_old_2 = ones256();
+    m256 res_old_3 = ones256();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 4);
+        m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, ones256(),
+                                          load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy);
+        ptr += 16;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, ones256(),
+                                          load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+        m256 r_1 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, ones256(),
+                                          load2x128(ptr + 16));
+        CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 4);
+        m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks4_pck_fat(const struct FDR *fdr,
+                                               const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 32;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m256 *maskBase = getMaskBase_avx2(teddy);
+    const u32 *confBase = getConfBase_avx2(teddy, 4);
+
+    m256 res_old_1 = ones256();
+    m256 res_old_2 = ones256();
+    m256 res_old_3 = ones256();
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 16);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 16;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 4);
+        m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    if (ptr + 16 < buf_end) {
+        m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, ones256(),
+                                          load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+        ptr += 16;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+        m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, ones256(),
+                                          load2x128(ptr));
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit_teddy);
+        m256 r_1 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, ones256(),
+                                          load2x128(ptr + 16));
+        CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 16) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end,
+                                       a->buf_history, a->len_history, 4);
+        m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2,
+                                          &res_old_3, p_mask, val_0);
+        CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks1_fast(const struct FDR *fdr,
+                                            const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 64;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 1);
+
+    const m256 maskLo = set2x128(maskBase[0]);
+    const m256 maskHi = set2x128(maskBase[1]);
+    const m256 mask = set32x8(0xf);
+    u16 bitArr[512];
+
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 32);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 32;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad256(&p_mask, ptr, a->buf + a->start_offset,
+                                     buf_end, a->buf_history, a->len_history);
+        m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi,
+                                             p_mask);
+        CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit1_fast_teddy);
+        ptr += 32;
+    }
+
+    if (ptr + 32 < buf_end) {
+        m256 val_0 = load256(ptr + 0);
+        m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi,
+                                             ones256());
+        CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit1_fast_teddy);
+        ptr += 32;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+
+        m256 val_0 = load256(ptr + 0);
+        m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi,
+                                             ones256());
+        CONFIRM_FAST_TEDDY(res_0, 0, NOT_CAUTIOUS, do_confWithBit1_fast_teddy);
+
+        m256 val_1 = load256(ptr + 32);
+        m256 res_1 = prep_conf_fast_teddy_m1(val_1, mask, maskLo, maskHi,
+                                             ones256());
+        CONFIRM_FAST_TEDDY(res_1, 4, NOT_CAUTIOUS, do_confWithBit1_fast_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 32) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad256(&p_mask, ptr, a->buf + a->start_offset,
+                                     buf_end, a->buf_history, a->len_history);
+        m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi,
+                                             p_mask);
+        CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit1_fast_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+hwlm_error_t fdr_exec_teddy_avx2_msks1_pck_fast(const struct FDR *fdr,
+                                                const struct FDR_Runtime_Args *a) {
+    const u8 *buf_end = a->buf + a->len;
+    const u8 *ptr = a->buf + a->start_offset;
+    hwlmcb_rv_t controlVal = *a->groups;
+    hwlmcb_rv_t *control = &controlVal;
+    u32 floodBackoff = FLOOD_BACKOFF_START;
+    const u8 *tryFloodDetect = a->firstFloodDetect;
+    u32 last_match = (u32)-1;
+    const struct Teddy *teddy = (const struct Teddy *)fdr;
+    const size_t iterBytes = 64;
+    DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n",
+                 a->buf, a->len, a->start_offset);
+
+    const m128 *maskBase = getMaskBase(teddy);
+    const u32 *confBase = getConfBase(teddy, 1);
+
+    const m256 maskLo = set2x128(maskBase[0]);
+    const m256 maskHi = set2x128(maskBase[1]);
+    const m256 mask = set32x8(0xf);
+    u16 bitArr[512];
+
+    const u8 *mainStart = ROUNDUP_PTR(ptr, 32);
+    DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart);
+    if (ptr < mainStart) {
+        ptr = mainStart - 32;
+        m256 p_mask;
+        m256 val_0 = vectoredLoad256(&p_mask, ptr, a->buf + a->start_offset,
+                                     buf_end, a->buf_history, a->len_history);
+        m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi,
+                                             p_mask);
+        CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit_fast_teddy);
+        ptr += 32;
+    }
+
+    if (ptr + 32 < buf_end) {
+        m256 val_0 = load256(ptr + 0);
+        m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi,
+                                             ones256());
+        CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit_fast_teddy);
+        ptr += 32;
+    }
+
+    for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) {
+        __builtin_prefetch(ptr + (iterBytes*4));
+        CHECK_FLOOD;
+
+        m256 val_0 = load256(ptr + 0);
+        m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi,
+                                             ones256());
+        CONFIRM_FAST_TEDDY(res_0, 0, NOT_CAUTIOUS, do_confWithBit_fast_teddy);
+
+        m256 val_1 = load256(ptr + 32);
+        m256 res_1 = prep_conf_fast_teddy_m1(val_1, mask, maskLo, maskHi,
+                                             ones256());
+        CONFIRM_FAST_TEDDY(res_1, 4, NOT_CAUTIOUS, do_confWithBit_fast_teddy);
+    }
+
+    for (; ptr < buf_end; ptr += 32) {
+        m256 p_mask;
+        m256 val_0 = vectoredLoad256(&p_mask, ptr, a->buf + a->start_offset,
+                                     buf_end, a->buf_history, a->len_history);
+        m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi,
+                                             p_mask);
+        CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit_fast_teddy);
+    }
+    *a->groups = controlVal;
+    return HWLM_SUCCESS;
+}
+
+#endif // __AVX2__
diff --git a/src/fdr/teddy_compile.cpp b/src/fdr/teddy_compile.cpp
index cc8c3374..c1e46d85 100644
--- a/src/fdr/teddy_compile.cpp
+++ b/src/fdr/teddy_compile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
diff --git a/src/fdr/teddy_engine_description.cpp b/src/fdr/teddy_engine_description.cpp
index 87edcbe5..d95f4937 100644
--- a/src/fdr/teddy_engine_description.cpp
+++ b/src/fdr/teddy_engine_description.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,7 +26,6 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "fdr.h"
 #include "fdr_internal.h"
 #include "fdr_compile_internal.h"
 #include "fdr_confirm.h"
@@ -65,7 +64,32 @@ bool TeddyEngineDescription::needConfirm(const vector<hwlmLiteral> &lits) const
     return false;
 }
 
-#include "teddy_autogen_compiler.cpp"
+void getTeddyDescriptions(vector<TeddyEngineDescription> *out) {
+    static const TeddyEngineDef defns[] = {
+        { 1, 0 | HS_CPU_FEATURES_AVX2, 1, 8, false, 0, 1 },
+        { 2, 0 | HS_CPU_FEATURES_AVX2, 1, 8, true, 0, 32 },
+        { 3, 0 | HS_CPU_FEATURES_AVX2, 1, 16, false, 0, 1 },
+        { 4, 0 | HS_CPU_FEATURES_AVX2, 1, 16, true, 0, 32 },
+        { 5, 0 | HS_CPU_FEATURES_AVX2, 2, 16, false, 0, 1 },
+        { 6, 0 | HS_CPU_FEATURES_AVX2, 2, 16, true, 0, 32 },
+        { 7, 0 | HS_CPU_FEATURES_AVX2, 3, 16, false, 0, 1 },
+        { 8, 0 | HS_CPU_FEATURES_AVX2, 3, 16, true, 0, 32 },
+        { 9, 0 | HS_CPU_FEATURES_AVX2, 4, 16, false, 0, 1 },
+        { 10, 0 | HS_CPU_FEATURES_AVX2, 4, 16, true, 0, 32 },
+        { 11, 0, 1, 8, false, 0, 1 },
+        { 12, 0, 1, 8, true, 0, 32 },
+        { 13, 0, 2, 8, false, 0, 1 },
+        { 14, 0, 2, 8, true, 0, 32 },
+        { 15, 0, 3, 8, false, 0, 1 },
+        { 16, 0, 3, 8, true, 0, 32 },
+        { 17, 0, 4, 8, false, 0, 1 },
+        { 18, 0, 4, 8, true, 0, 32 },
+    };
+    out->clear();
+    for (const auto &def : defns) {
+        out->emplace_back(def);
+    }
+}
 
 static
 size_t maxFloodTailLen(const vector<hwlmLiteral> &vl) {
diff --git a/src/fdr/teddy_runtime_common.h b/src/fdr/teddy_runtime_common.h
new file mode 100644
index 00000000..c50b4d16
--- /dev/null
+++ b/src/fdr/teddy_runtime_common.h
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** \file
+ * \brief Teddy literal matcher: common runtime procedures.
+ */
+
+#ifndef TEDDY_RUNTIME_COMMON_H_
+#define TEDDY_RUNTIME_COMMON_H_
+
+#include "fdr_confirm.h"
+#include "fdr_confirm_runtime.h"
+#include "ue2common.h"
+#include "util/bitutils.h"
+#include "util/simd_utils.h"
+
+extern const u8 ALIGN_DIRECTIVE p_mask_arr[17][32];
+
+#ifdef ARCH_64_BIT
+#define TEDDY_CONF_TYPE u64a
+#define TEDDY_FIND_AND_CLEAR_LSB(conf) findAndClearLSB_64(conf)
+#else
+#define TEDDY_CONF_TYPE u32
+#define TEDDY_FIND_AND_CLEAR_LSB(conf) findAndClearLSB_32(conf)
+#endif
+
+#define CHECK_HWLM_TERMINATE_MATCHING                                       \
+do {                                                                        \
+    if (unlikely(controlVal == HWLM_TERMINATE_MATCHING)) {                  \
+        *a->groups = controlVal;                                            \
+        return HWLM_TERMINATED;                                             \
+    }                                                                       \
+} while (0);
+
+#define CHECK_FLOOD                                                         \
+do {                                                                        \
+    if (unlikely(ptr > tryFloodDetect)) {                                   \
+        tryFloodDetect = floodDetect(fdr, a, &ptr, tryFloodDetect,          \
+                                     &floodBackoff, &controlVal,            \
+                                     iterBytes);                            \
+        CHECK_HWLM_TERMINATE_MATCHING;                                      \
+    }                                                                       \
+} while (0);
+
+/*
+ * \brief Copy a block of [0,15] bytes efficiently.
+ *
+ * This function is a workaround intended to stop some compilers from
+ * synthesizing a memcpy function call out of the copy of a small number of
+ * bytes that we do in vectoredLoad128.
+ */
+static really_inline
+void copyRuntBlock128(u8 *dst, const u8 *src, size_t len) {
+    switch (len) {
+    case 0:
+        break;
+    case 1:
+        *dst = *src;
+        break;
+    case 2:
+        unaligned_store_u16(dst, unaligned_load_u16(src));
+        break;
+    case 3:
+        unaligned_store_u16(dst, unaligned_load_u16(src));
+        dst[2] = src[2];
+        break;
+    case 4:
+        unaligned_store_u32(dst, unaligned_load_u32(src));
+        break;
+    case 5:
+    case 6:
+    case 7:
+        /* Perform copy with two overlapping 4-byte chunks. */
+        unaligned_store_u32(dst + len - 4, unaligned_load_u32(src + len - 4));
+        unaligned_store_u32(dst, unaligned_load_u32(src));
+        break;
+    case 8:
+        unaligned_store_u64a(dst, unaligned_load_u64a(src));
+        break;
+    default:
+        /* Perform copy with two overlapping 8-byte chunks. */
+        assert(len < 16);
+        unaligned_store_u64a(dst + len - 8, unaligned_load_u64a(src + len - 8));
+        unaligned_store_u64a(dst, unaligned_load_u64a(src));
+        break;
+    }
+}
+
+// Note: p_mask is an output param that initialises a poison mask.
+static really_inline
+m128 vectoredLoad128(m128 *p_mask, const u8 *ptr, const u8 *lo, const u8 *hi,
+                     const u8 *buf_history, size_t len_history,
+                     const u32 nMasks) {
+    union {
+        u8 val8[16];
+        m128 val128;
+    } u;
+    u.val128 = zeroes128();
+
+    uintptr_t copy_start;
+    uintptr_t copy_len;
+
+    if (ptr >= lo) {
+        uintptr_t avail = (uintptr_t)(hi - ptr);
+        if (avail >= 16) {
+            *p_mask = load128(p_mask_arr[16] + 16);
+            return loadu128(ptr);
+        }
+        *p_mask = load128(p_mask_arr[avail] + 16);
+        copy_start = 0;
+        copy_len = avail;
+    } else {
+        uintptr_t need = MIN((uintptr_t)(lo - ptr),
+                             MIN(len_history, nMasks - 1));
+        uintptr_t start = (uintptr_t)(lo - ptr);
+        uintptr_t i;
+        for (i = start - need; ptr + i < lo; i++) {
+            u.val8[i] = buf_history[len_history - (lo - (ptr + i))];
+        }
+        uintptr_t end = MIN(16, (uintptr_t)(hi - ptr));
+        *p_mask = loadu128(p_mask_arr[end - start] + 16 - start);
+        copy_start = i;
+        copy_len = end - i;
+    }
+
+    // Runt block from the buffer.
+    copyRuntBlock128(&u.val8[copy_start], &ptr[copy_start], copy_len);
+
+    return u.val128;
+}
+
+static really_inline
+u64a getConfVal(const struct FDR_Runtime_Args *a, const u8 *ptr, u32 byte,
+                CautionReason reason) {
+    u64a confVal = 0;
+    const u8 *buf = a->buf;
+    size_t len = a->len;
+    const u8 *confirm_loc = ptr + byte - 7;
+    if (likely(reason == NOT_CAUTIOUS || confirm_loc >= buf)) {
+        confVal = lv_u64a(confirm_loc, buf, buf + len);
+    } else { // r == VECTORING, confirm_loc < buf
+        u64a histBytes = a->histBytes;
+        confVal = lv_u64a_ce(confirm_loc, buf, buf + len);
+        // stitch together confVal and history
+        u32 overhang = buf - confirm_loc;
+        histBytes >>= 64 - (overhang * 8);
+        confVal |= histBytes;
+    }
+    return confVal;
+}
+
+static really_inline
+void do_confWithBit_teddy(TEDDY_CONF_TYPE *conf, u8 bucket, u8 offset,
+                          const u32 *confBase, CautionReason reason,
+                          const struct FDR_Runtime_Args *a, const u8 *ptr,
+                          hwlmcb_rv_t *control, u32 *last_match) {
+    do  {
+        u32 bit = TEDDY_FIND_AND_CLEAR_LSB(conf);
+        u32 byte = bit / bucket + offset;
+        u32 bitRem  = bit % bucket;
+        u32 confSplit = *(ptr+byte) & 0x1f;
+        u32 idx = confSplit * bucket + bitRem;
+        u32 cf = confBase[idx];
+        if (!cf) {
+            continue;
+        }
+        const struct FDRConfirm *fdrc = (const struct FDRConfirm *)
+                                        ((const u8 *)confBase + cf);
+        if (!(fdrc->groups & *control)) {
+            continue;
+        }
+        u64a confVal = getConfVal(a, ptr, byte, reason);
+        confWithBit(fdrc, a, ptr - a->buf + byte, 0, control,
+                    last_match, confVal);
+    } while (unlikely(*conf));
+}
+
+static really_inline
+void do_confWithBit1_teddy(TEDDY_CONF_TYPE *conf, u8 bucket, u8 offset,
+                           const u32 *confBase, CautionReason reason,
+                           const struct FDR_Runtime_Args *a, const u8 *ptr,
+                           hwlmcb_rv_t *control, u32 *last_match) {
+    do {
+        u32 bit = TEDDY_FIND_AND_CLEAR_LSB(conf);
+        u32 byte = bit / bucket + offset;
+        u32 idx  = bit % bucket;
+        u32 cf = confBase[idx];
+        const struct FDRConfirm *fdrc = (const struct FDRConfirm *)
+                                        ((const u8 *)confBase + cf);
+        if (!(fdrc->groups & *control)) {
+            continue;
+        }
+        u64a confVal = getConfVal(a, ptr, byte, reason);
+        confWithBit1(fdrc, a, ptr - a->buf + byte, control, last_match,
+                     confVal);
+    } while (unlikely(*conf));
+}
+
+static really_inline
+void do_confWithBitMany_teddy(TEDDY_CONF_TYPE *conf, u8 bucket, u8 offset,
+                              const u32 *confBase, CautionReason reason,
+                              const struct FDR_Runtime_Args *a, const u8 *ptr,
+                              hwlmcb_rv_t *control, u32 *last_match) {
+    do {
+        u32 bit = TEDDY_FIND_AND_CLEAR_LSB(conf);
+        u32 byte = bit / bucket + offset;
+        u32 idx = bit % bucket;
+        u32 cf = confBase[idx];
+        const struct FDRConfirm *fdrc = (const struct FDRConfirm *)
+                                        ((const u8 *)confBase + cf);
+        if (!(fdrc->groups & *control)) {
+            continue;
+        }
+        u64a confVal = getConfVal(a, ptr, byte, reason);
+        confWithBitMany(fdrc, a, ptr - a->buf + byte, reason, control,
+                        last_match, confVal);
+    } while (unlikely(*conf));
+}
+
+static really_inline
+const m128 * getMaskBase(const struct Teddy *teddy) {
+    return (const m128 *)((const u8 *)teddy + sizeof(struct Teddy));
+}
+
+static really_inline
+const u32 * getConfBase(const struct Teddy *teddy, u8 numMask) {
+    return (const u32 *)((const u8 *)teddy + sizeof(struct Teddy) +
+                         (numMask*32));
+}
+
+#endif /* TEDDY_RUNTIME_COMMON_H_ */
diff --git a/src/grey.cpp b/src/grey.cpp
index 3f169976..69dab627 100644
--- a/src/grey.cpp
+++ b/src/grey.cpp
@@ -54,7 +54,6 @@ Grey::Grey(void) :
                    allowRose(true),
                    allowExtendedNFA(true), /* bounded repeats of course */
                    allowLimExNFA(true),
-                   allowSidecar(true),
                    allowAnchoredAcyclic(true),
                    allowSmallLiteralSet(true),
                    allowCastle(true),
@@ -207,7 +206,6 @@ void applyGreyOverrides(Grey *g, const string &s) {
         G_UPDATE(allowRose);
         G_UPDATE(allowExtendedNFA);
         G_UPDATE(allowLimExNFA);
-        G_UPDATE(allowSidecar);
         G_UPDATE(allowAnchoredAcyclic);
         G_UPDATE(allowSmallLiteralSet);
         G_UPDATE(allowCastle);
diff --git a/src/grey.h b/src/grey.h
index 10379e1a..a2261052 100644
--- a/src/grey.h
+++ b/src/grey.h
@@ -54,7 +54,6 @@ struct Grey {
     bool allowRose;
     bool allowExtendedNFA;
     bool allowLimExNFA;
-    bool allowSidecar;
     bool allowAnchoredAcyclic;
     bool allowSmallLiteralSet;
     bool allowCastle;
diff --git a/src/hs.cpp b/src/hs.cpp
index e665539b..3680e79e 100644
--- a/src/hs.cpp
+++ b/src/hs.cpp
@@ -39,6 +39,7 @@
 #include "compiler/error.h"
 #include "nfagraph/ng.h"
 #include "nfagraph/ng_expr_info.h"
+#include "nfagraph/ng_extparam.h"
 #include "parser/parse_error.h"
 #include "parser/Parser.h"
 #include "parser/prefilter.h"
@@ -310,7 +311,8 @@ hs_error_t hs_compile_ext_multi(const char * const *expressions,
 
 static
 hs_error_t hs_expression_info_int(const char *expression, unsigned int flags,
-                                  unsigned int mode, hs_expr_info_t **info,
+                                  const hs_expr_ext_t *ext, unsigned int mode,
+                                  hs_expr_info_t **info,
                                   hs_compile_error_t **error) {
     if (!error) {
         // nowhere to write an error, but we can still return an error code.
@@ -347,7 +349,7 @@ hs_error_t hs_expression_info_int(const char *expression, unsigned int flags,
         }
 
         ReportManager rm(cc.grey);
-        ParsedExpression pe(0, expression, flags, 0);
+        ParsedExpression pe(0, expression, flags, 0, ext);
         assert(pe.component);
 
         // Apply prefiltering transformations if desired.
@@ -362,6 +364,7 @@ hs_error_t hs_expression_info_int(const char *expression, unsigned int flags,
             throw ParseError("Internal error.");
         }
 
+        handleExtendedParams(rm, *g, cc);
         fillExpressionInfo(rm, *g, &local_info);
     }
     catch (const CompileError &e) {
@@ -394,7 +397,16 @@ extern "C" HS_PUBLIC_API
 hs_error_t hs_expression_info(const char *expression, unsigned int flags,
                               hs_expr_info_t **info,
                               hs_compile_error_t **error) {
-    return hs_expression_info_int(expression, flags, HS_MODE_BLOCK, info,
+    return hs_expression_info_int(expression, flags, nullptr, HS_MODE_BLOCK,
+                                  info, error);
+}
+
+extern "C" HS_PUBLIC_API
+hs_error_t hs_expression_ext_info(const char *expression, unsigned int flags,
+                                  const hs_expr_ext_t *ext,
+                                  hs_expr_info_t **info,
+                                  hs_compile_error_t **error) {
+    return hs_expression_info_int(expression, flags, ext, HS_MODE_BLOCK, info,
                                   error);
 }
 
diff --git a/src/hs_common.h b/src/hs_common.h
index b38d9505..4bf31146 100644
--- a/src/hs_common.h
+++ b/src/hs_common.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -500,6 +500,25 @@ const char *hs_version(void);
  */
 #define HS_BAD_ALLOC            (-9)
 
+/**
+ * The scratch region was already in use.
+ *
+ * This error is returned when Hyperscan is able to detect that the scratch
+ * region given is already in use by another Hyperscan API call.
+ *
+ * A separate scratch region, allocated with @ref hs_alloc_scratch() or @ref
+ * hs_clone_scratch(), is required for every concurrent caller of the Hyperscan
+ * API.
+ *
+ * For example, this error might be returned when @ref hs_scan() has been
+ * called inside a callback delivered by a currently-executing @ref hs_scan()
+ * call using the same scratch region.
+ *
+ * Note: Not all concurrent uses of scratch regions may be detected. This error
+ * is intended as a best-effort debugging tool, not a guarantee.
+ */
+#define HS_SCRATCH_IN_USE       (-10)
+
 /** @} */
 
 #ifdef __cplusplus
diff --git a/src/hs_compile.h b/src/hs_compile.h
index 68f38584..48168cc2 100644
--- a/src/hs_compile.h
+++ b/src/hs_compile.h
@@ -158,7 +158,7 @@ typedef struct hs_platform_info {
 
 /**
  * A type containing information related to an expression that is returned by
- * @ref hs_expression_info().
+ * @ref hs_expression_info() or @ref hs_expression_ext_info.
  */
 typedef struct hs_expr_info {
     /**
@@ -201,7 +201,8 @@ typedef struct hs_expr_info {
 
 /**
  * A structure containing additional parameters related to an expression,
- * passed in at build time to @ref hs_compile_ext_multi().
+ * passed in at build time to @ref hs_compile_ext_multi() or @ref
+ * hs_expression_ext_info.
  *
  * These parameters allow the set of matches produced by a pattern to be
  * constrained at compile time, rather than relying on the application to
@@ -401,7 +402,7 @@ hs_error_t hs_compile_multi(const char *const *expressions,
                             hs_database_t **db, hs_compile_error_t **error);
 
 /**
- * The multiple regular expression compiler with extended pattern support.
+ * The multiple regular expression compiler with extended parameter support.
  *
  * This function call compiles a group of expressions into a database in the
  * same way as @ref hs_compile_multi(), but allows additional parameters to be
@@ -550,6 +551,62 @@ hs_error_t hs_expression_info(const char *expression, unsigned int flags,
                               hs_expr_info_t **info,
                               hs_compile_error_t **error);
 
+/**
+ * Utility function providing information about a regular expression, with
+ * extended parameter support. The information provided in @ref hs_expr_info_t
+ * includes the minimum and maximum width of a pattern match.
+ *
+ * @param expression
+ *      The NULL-terminated expression to parse. Note that this string must
+ *      represent ONLY the pattern to be matched, with no delimiters or flags;
+ *      any global flags should be specified with the @a flags argument.  For
+ *      example, the expression `/abc?def/i` should be compiled by providing
+ *      `abc?def` as the @a expression, and @ref HS_FLAG_CASELESS as the @a
+ *      flags.
+ *
+ * @param flags
+ *      Flags which modify the behaviour of the expression. Multiple flags may
+ *      be used by ORing them together. Valid values are:
+ *       - HS_FLAG_CASELESS - Matching will be performed case-insensitively.
+ *       - HS_FLAG_DOTALL - Matching a `.` will not exclude newlines.
+ *       - HS_FLAG_MULTILINE - `^` and `$` anchors match any newlines in data.
+ *       - HS_FLAG_SINGLEMATCH - Only one match will be generated by the
+ *                               expression per stream.
+ *       - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an
+ *                              empty string, such as `.*`.
+ *       - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters.
+ *       - HS_FLAG_UCP - Use Unicode properties for character classes.
+ *       - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode.
+ *       - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset
+ *                                when a match is found.
+ *
+ * @param ext
+ *      A pointer to a filled @ref hs_expr_ext_t structure that defines
+ *      extended behaviour for this pattern. NULL may be specified if no
+ *      extended parameters are needed.
+ *
+ * @param info
+ *      On success, a pointer to the pattern information will be returned in
+ *      this parameter, or NULL on failure. This structure is allocated using
+ *      the allocator supplied in @ref hs_set_allocator() (or malloc() if no
+ *      allocator was set) and should be freed by the caller.
+ *
+ * @param error
+ *      If the call fails, a pointer to a @ref hs_compile_error_t will be
+ *      returned, providing details of the error condition. The caller is
+ *      responsible for deallocating the buffer using the @ref
+ *      hs_free_compile_error() function.
+ *
+ * @return
+ *      @ref HS_SUCCESS is returned on successful compilation; @ref
+ *      HS_COMPILER_ERROR on failure, with details provided in the error
+ *      parameter.
+ */
+hs_error_t hs_expression_ext_info(const char *expression, unsigned int flags,
+                                  const hs_expr_ext_t *ext,
+                                  hs_expr_info_t **info,
+                                  hs_compile_error_t **error);
+
 /**
  * Populates the platform information based on the current host.
  *
diff --git a/src/hwlm/hwlm_build.cpp b/src/hwlm/hwlm_build.cpp
index 0de120ba..b3978017 100644
--- a/src/hwlm/hwlm_build.cpp
+++ b/src/hwlm/hwlm_build.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -37,7 +37,6 @@
 #include "noodle_build.h"
 #include "ue2common.h"
 #include "fdr/fdr_compile.h"
-#include "fdr/fdr.h"
 #include "nfa/shufticompile.h"
 #include "util/alloc.h"
 #include "util/bitutils.h"
@@ -526,8 +525,7 @@ aligned_unique_ptr<HWLM> hwlmBuild(const vector<hwlmLiteral> &lits,
         DEBUG_PRINTF("build noodle table\n");
         engType = HWLM_ENGINE_NOOD;
         const hwlmLiteral &lit = lits.front();
-        auto noodle = noodBuildTable((const u8 *)lit.s.c_str(), lit.s.length(),
-                                     lit.nocase, lit.id);
+        auto noodle = noodBuildTable(lit);
         if (noodle) {
             engSize = noodSize(noodle.get());
         }
diff --git a/src/hwlm/hwlm_literal.cpp b/src/hwlm/hwlm_literal.cpp
index 4d8b4336..9e365a0c 100644
--- a/src/hwlm/hwlm_literal.cpp
+++ b/src/hwlm/hwlm_literal.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -34,13 +34,11 @@
 #include "util/compare.h" // for ourisalpha
 #include "util/ue2string.h" // for escapeString
 
+#include <algorithm>
 #include <iomanip>
 #include <sstream>
 
-#include <boost/algorithm/cxx11/all_of.hpp>
-
 using namespace std;
-using namespace boost::algorithm;
 
 namespace ue2 {
 
@@ -91,10 +89,17 @@ hwlmLiteral::hwlmLiteral(const std::string &s_in, bool nocase_in,
     assert(msk.size() <= HWLM_MASKLEN);
     assert(msk.size() == cmp.size());
 
-    DEBUG_PRINTF("literal '%s', msk=%s, cmp=%s\n",
-                 escapeString(s).c_str(), dumpMask(msk).c_str(),
+    // If we've been handled a nocase literal, all letter characters must be
+    // upper-case.
+    if (nocase) {
+        upperString(s);
+    }
+
+    DEBUG_PRINTF("literal '%s'%s, msk=%s, cmp=%s\n", escapeString(s).c_str(),
+                 nocase ? " (nocase)" : "", dumpMask(msk).c_str(),
                  dumpMask(cmp).c_str());
 
+
     // Mask and compare vectors MUST be the same size.
     assert(msk.size() == cmp.size());
 
@@ -102,7 +107,7 @@ hwlmLiteral::hwlmLiteral(const std::string &s_in, bool nocase_in,
     assert(maskIsConsistent(s, nocase, msk, cmp));
 
     // In the name of good hygiene, zap msk/cmp if msk is all zeroes.
-    if (all_of_equal(msk.begin(), msk.end(), 0)) {
+    if (all_of(begin(msk), end(msk), [](u8 val) { return val == 0; })) {
         msk.clear();
         cmp.clear();
     }
diff --git a/src/hwlm/hwlm_literal.h b/src/hwlm/hwlm_literal.h
index ca9695bc..7e63a6f3 100644
--- a/src/hwlm/hwlm_literal.h
+++ b/src/hwlm/hwlm_literal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -95,11 +95,6 @@ struct hwlmLiteral {
      */
     std::vector<u8> cmp;
 
-    /** \brief Simple constructor: no group information, no msk/cmp. */
-    hwlmLiteral(const std::string &s_in, bool nocase_in, u32 id_in)
-        : s(s_in), id(id_in), nocase(nocase_in), noruns(false),
-          groups(HWLM_ALL_GROUPS), msk(0), cmp(0) {}
-
     /** \brief Complete constructor, takes group information and msk/cmp.
      *
      * This constructor takes a msk/cmp pair. Both must be vectors of length <=
@@ -107,6 +102,10 @@ struct hwlmLiteral {
     hwlmLiteral(const std::string &s_in, bool nocase_in, bool noruns_in,
                 u32 id_in, hwlm_group_t groups_in,
                 const std::vector<u8> &msk_in, const std::vector<u8> &cmp_in);
+
+    /** \brief Simple constructor: no group information, no msk/cmp. */
+    hwlmLiteral(const std::string &s_in, bool nocase_in, u32 id_in)
+        : hwlmLiteral(s_in, nocase_in, false, id_in, HWLM_ALL_GROUPS, {}, {}) {}
 };
 
 /**
diff --git a/src/hwlm/noodle_build.cpp b/src/hwlm/noodle_build.cpp
index 9e087211..d2b4e3f2 100644
--- a/src/hwlm/noodle_build.cpp
+++ b/src/hwlm/noodle_build.cpp
@@ -26,28 +26,35 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-/** \file
+/**
+ * \file
  * \brief Noodle literal matcher: build code.
  */
-#include <cstring> // for memcpy
 
 #include "noodle_build.h"
+
+#include "hwlm_literal.h"
 #include "noodle_internal.h"
-#include "ue2common.h"
 #include "util/alloc.h"
 #include "util/compare.h"
 #include "util/verify_types.h"
+#include "ue2common.h"
+
+#include <cstring> // for memcpy
 
 namespace ue2 {
 
 static
-size_t findNoodFragOffset(const u8 *lit, size_t len, bool nocase) {
+size_t findNoodFragOffset(const hwlmLiteral &lit) {
+    const auto &s = lit.s;
+    const size_t len = lit.s.length();
+
     size_t offset = 0;
     for (size_t i = 0; i + 1 < len; i++) {
         int diff = 0;
-        const char c = lit[i];
-        const char d = lit[i + 1];
-        if (nocase && ourisalpha(c)) {
+        const char c = s[i];
+        const char d = s[i + 1];
+        if (lit.nocase && ourisalpha(c)) {
             diff = (mytoupper(c) != mytoupper(d));
         } else {
             diff = (c != d);
@@ -60,21 +67,24 @@ size_t findNoodFragOffset(const u8 *lit, size_t len, bool nocase) {
     return offset;
 }
 
-/** \brief Construct a Noodle matcher for the given literal. */
-aligned_unique_ptr<noodTable> noodBuildTable(const u8 *lit, size_t len,
-                                             bool nocase, u32 id) {
-    size_t noodle_len = sizeof(noodTable) + len;
-    aligned_unique_ptr<noodTable> n =
-        aligned_zmalloc_unique<noodTable>(noodle_len);
+aligned_unique_ptr<noodTable> noodBuildTable(const hwlmLiteral &lit) {
+    if (!lit.msk.empty()) {
+        DEBUG_PRINTF("noodle can't handle supplementary masks\n");
+        return nullptr;
+    }
+
+    const auto &s = lit.s;
+    size_t noodle_len = sizeof(noodTable) + s.length();
+    auto n = aligned_zmalloc_unique<noodTable>(noodle_len);
     assert(n);
 
-    size_t key_offset = findNoodFragOffset(lit, len, nocase);
+    size_t key_offset = findNoodFragOffset(lit);
 
-    n->id = id;
-    n->len = verify_u32(len);
+    n->id = lit.id;
+    n->len = verify_u32(s.length());
     n->key_offset = verify_u32(key_offset);
-    n->nocase = nocase ? 1 : 0;
-    memcpy(n->str, lit, len);
+    n->nocase = lit.nocase ? 1 : 0;
+    memcpy(n->str, s.c_str(), s.length());
 
     return n;
 }
diff --git a/src/hwlm/noodle_build.h b/src/hwlm/noodle_build.h
index 3e8f5cb5..1a41695f 100644
--- a/src/hwlm/noodle_build.h
+++ b/src/hwlm/noodle_build.h
@@ -40,9 +40,10 @@ struct noodTable;
 
 namespace ue2 {
 
+struct hwlmLiteral;
+
 /** \brief Construct a Noodle matcher for the given literal. */
-ue2::aligned_unique_ptr<noodTable> noodBuildTable(const u8 *lit, size_t len,
-                                                  bool nocase, u32 id);
+ue2::aligned_unique_ptr<noodTable> noodBuildTable(const hwlmLiteral &lit);
 
 size_t noodSize(const noodTable *n);
 
diff --git a/src/hwlm/noodle_engine.c b/src/hwlm/noodle_engine.c
index 621f89b0..e2f80a59 100644
--- a/src/hwlm/noodle_engine.c
+++ b/src/hwlm/noodle_engine.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -37,6 +37,7 @@
 #include "util/compare.h"
 #include "util/masked_move.h"
 #include "util/simd_utils.h"
+#include "util/simd_utils_ssse3.h"
 
 #include <ctype.h>
 #include <stdbool.h>
diff --git a/src/hwlm/noodle_engine_avx2.c b/src/hwlm/noodle_engine_avx2.c
index 093501cb..14d0eab5 100644
--- a/src/hwlm/noodle_engine_avx2.c
+++ b/src/hwlm/noodle_engine_avx2.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -221,7 +221,7 @@ hwlm_error_t scanDoubleFast(const u8 *buf, size_t len, const u8 *key,
         u32 z0 = movemask256(eq256(mask1, v));
         u32 z1 = movemask256(eq256(mask2, v));
         u32 z = (lastz0 | (z0 << 1)) & z1;
-        lastz0 = (z0 & 0x80000000) >> 31;
+        lastz0 = z0 >> 31;
 
         // On large packet buffers, this prefetch appears to get us about 2%.
         __builtin_prefetch(d + 128);
diff --git a/src/hwlm/noodle_engine_sse.c b/src/hwlm/noodle_engine_sse.c
index 956fd82e..b3673246 100644
--- a/src/hwlm/noodle_engine_sse.c
+++ b/src/hwlm/noodle_engine_sse.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -190,8 +190,8 @@ hwlm_error_t scanDoubleFast(const u8 *buf, size_t len, const u8 *key,
         m128 v = noCase ? and128(load128(d), caseMask) : load128(d);
         m128 z1 = eq128(mask1, v);
         m128 z2 = eq128(mask2, v);
-        u32 z = movemask128(and128(or128(lastz1, shiftLeft8Bits(z1)), z2));
-        lastz1 = _mm_srli_si128(z1, 15);
+        u32 z = movemask128(and128(palignr(z1, lastz1, 15), z2));
+        lastz1 = z1;
 
         // On large packet buffers, this prefetch appears to get us about 2%.
         __builtin_prefetch(d + 128);
diff --git a/src/nfa/accel.c b/src/nfa/accel.c
index af5e9610..99eab11d 100644
--- a/src/nfa/accel.c
+++ b/src/nfa/accel.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -30,6 +30,9 @@
 #include "shufti.h"
 #include "truffle.h"
 #include "vermicelli.h"
+#include "multishufti.h"
+#include "multitruffle.h"
+#include "multivermicelli.h"
 #include "ue2common.h"
 
 const u8 *run_accel(const union AccelAux *accel, const u8 *c, const u8 *c_end) {
@@ -81,6 +84,18 @@ const u8 *run_accel(const union AccelAux *accel, const u8 *c, const u8 *c_end) {
                                   c_end - 1);
         break;
 
+    case ACCEL_DVERM_MASKED:
+        DEBUG_PRINTF("accel dverm masked %p %p\n", c, c_end);
+        if (c + 16 + 1 >= c_end) {
+            return c;
+        }
+
+        /* need to stop one early to get an accurate end state */
+        rv = vermicelliDoubleMaskedExec(accel->dverm.c1, accel->dverm.c2,
+                                        accel->dverm.m1, accel->dverm.m2,
+                                        c, c_end - 1);
+        break;
+
     case ACCEL_SHUFTI:
         DEBUG_PRINTF("accel shufti %p %p\n", c, c_end);
         if (c + 15 >= c_end) {
@@ -117,6 +132,221 @@ const u8 *run_accel(const union AccelAux *accel, const u8 *c, const u8 *c_end) {
         rv = c_end;
         break;
 
+    /* multibyte matchers */
+    case ACCEL_MLVERM:
+        DEBUG_PRINTF("accel mlverm %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = long_vermicelliExec(accel->mverm.c, 0, c, c_end, accel->mverm.len);
+        break;
+    case ACCEL_MLVERM_NOCASE:
+        DEBUG_PRINTF("accel mlverm nc %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = long_vermicelliExec(accel->mverm.c, 1, c, c_end, accel->mverm.len);
+        break;
+    case ACCEL_MLGVERM:
+        DEBUG_PRINTF("accel mlgverm %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = longgrab_vermicelliExec(accel->mverm.c, 0, c, c_end, accel->mverm.len);
+        break;
+    case ACCEL_MLGVERM_NOCASE:
+        DEBUG_PRINTF("accel mlgverm nc %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = longgrab_vermicelliExec(accel->mverm.c, 1, c, c_end, accel->mverm.len);
+        break;
+    case ACCEL_MSVERM:
+        DEBUG_PRINTF("accel msverm %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = shift_vermicelliExec(accel->mverm.c, 0, c, c_end, accel->mverm.len);
+        break;
+    case ACCEL_MSVERM_NOCASE:
+        DEBUG_PRINTF("accel msverm nc %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = shift_vermicelliExec(accel->mverm.c, 1, c, c_end, accel->mverm.len);
+        break;
+    case ACCEL_MSGVERM:
+        DEBUG_PRINTF("accel msgverm %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = shiftgrab_vermicelliExec(accel->mverm.c, 0, c, c_end, accel->mverm.len);
+        break;
+    case ACCEL_MSGVERM_NOCASE:
+        DEBUG_PRINTF("accel msgverm nc %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = shiftgrab_vermicelliExec(accel->mverm.c, 1, c, c_end, accel->mverm.len);
+        break;
+    case ACCEL_MDSVERM:
+        DEBUG_PRINTF("accel mdsverm %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = doubleshift_vermicelliExec(accel->mdverm.c, 0, c, c_end,
+                                        accel->mdverm.len1, accel->mdverm.len2);
+        break;
+    case ACCEL_MDSVERM_NOCASE:
+        DEBUG_PRINTF("accel mdsverm nc %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = doubleshift_vermicelliExec(accel->mdverm.c, 1, c, c_end,
+                                        accel->mdverm.len1, accel->mdverm.len2);
+        break;
+    case ACCEL_MDSGVERM:
+        DEBUG_PRINTF("accel mdsgverm %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = doubleshiftgrab_vermicelliExec(accel->mdverm.c, 0, c, c_end,
+                                            accel->mdverm.len1, accel->mdverm.len2);
+        break;
+    case ACCEL_MDSGVERM_NOCASE:
+        DEBUG_PRINTF("accel mdsgverm nc %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = doubleshiftgrab_vermicelliExec(accel->mdverm.c, 1, c, c_end,
+                                            accel->mdverm.len1, accel->mdverm.len2);
+        break;
+    case ACCEL_MLSHUFTI:
+        DEBUG_PRINTF("accel mlshufti %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = long_shuftiExec(accel->mshufti.lo, accel->mshufti.hi, c, c_end,
+                             accel->mshufti.len);
+        break;
+    case ACCEL_MLGSHUFTI:
+        DEBUG_PRINTF("accel mlgshufti %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = longgrab_shuftiExec(accel->mshufti.lo, accel->mshufti.hi, c, c_end,
+                                 accel->mshufti.len);
+        break;
+    case ACCEL_MSSHUFTI:
+        DEBUG_PRINTF("accel msshufti %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = shift_shuftiExec(accel->mshufti.lo, accel->mshufti.hi, c, c_end,
+                              accel->mshufti.len);
+        break;
+    case ACCEL_MSGSHUFTI:
+        DEBUG_PRINTF("accel msgshufti %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = shiftgrab_shuftiExec(accel->mshufti.lo, accel->mshufti.hi, c, c_end,
+                                  accel->mshufti.len);
+        break;
+    case ACCEL_MDSSHUFTI:
+        DEBUG_PRINTF("accel mdsshufti %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = doubleshift_shuftiExec(accel->mdshufti.lo, accel->mdshufti.hi, c, c_end,
+                                     accel->mdshufti.len1, accel->mdshufti.len2);
+        break;
+    case ACCEL_MDSGSHUFTI:
+        DEBUG_PRINTF("accel msgshufti %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = doubleshiftgrab_shuftiExec(accel->mdshufti.lo, accel->mdshufti.hi, c, c_end,
+                                         accel->mdshufti.len1, accel->mdshufti.len2);
+        break;
+    case ACCEL_MLTRUFFLE:
+        DEBUG_PRINTF("accel mltruffle %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = long_truffleExec(accel->mtruffle.mask1, accel->mtruffle.mask2,
+                               c, c_end, accel->mtruffle.len);
+        break;
+    case ACCEL_MLGTRUFFLE:
+        DEBUG_PRINTF("accel mlgtruffle %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = longgrab_truffleExec(accel->mtruffle.mask1, accel->mtruffle.mask2,
+                                   c, c_end, accel->mtruffle.len);
+        break;
+    case ACCEL_MSTRUFFLE:
+        DEBUG_PRINTF("accel mstruffle %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = shift_truffleExec(accel->mtruffle.mask1, accel->mtruffle.mask2,
+                               c, c_end, accel->mtruffle.len);
+        break;
+    case ACCEL_MSGTRUFFLE:
+        DEBUG_PRINTF("accel msgtruffle %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = shiftgrab_truffleExec(accel->mtruffle.mask1, accel->mtruffle.mask2,
+                                   c, c_end, accel->mtruffle.len);
+        break;
+    case ACCEL_MDSTRUFFLE:
+        DEBUG_PRINTF("accel mdstruffle %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = doubleshift_truffleExec(accel->mdtruffle.mask1,
+                                     accel->mdtruffle.mask2, c, c_end,
+                                     accel->mdtruffle.len1,
+                                     accel->mdtruffle.len2);
+        break;
+    case ACCEL_MDSGTRUFFLE:
+        DEBUG_PRINTF("accel mdsgtruffle %p %p\n", c, c_end);
+        if (c + 15 >= c_end) {
+            return c;
+        }
+
+        rv = doubleshiftgrab_truffleExec(accel->mdtruffle.mask1,
+                                         accel->mdtruffle.mask2, c, c_end,
+                                         accel->mdtruffle.len1,
+                                         accel->mdtruffle.len2);
+        break;
+
+
     default:
         assert(!"not here");
         return c;
@@ -127,5 +357,7 @@ const u8 *run_accel(const union AccelAux *accel, const u8 *c, const u8 *c_end) {
     rv = MAX(c + accel->generic.offset, rv);
     rv -= accel->generic.offset;
 
+    DEBUG_PRINTF("advanced %zd\n", rv - c);
+
     return rv;
 }
diff --git a/src/nfa/accel.h b/src/nfa/accel.h
index 2c1f223a..a13563b6 100644
--- a/src/nfa/accel.h
+++ b/src/nfa/accel.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -60,7 +60,37 @@ enum AccelType {
     ACCEL_SHUFTI,
     ACCEL_DSHUFTI,
     ACCEL_TRUFFLE,
-    ACCEL_RED_TAPE
+    ACCEL_RED_TAPE,
+    /* multibyte vermicellis */
+    ACCEL_MLVERM,
+    ACCEL_MLVERM_NOCASE,
+    ACCEL_MLGVERM,
+    ACCEL_MLGVERM_NOCASE,
+    ACCEL_MSVERM,
+    ACCEL_MSVERM_NOCASE,
+    ACCEL_MSGVERM,
+    ACCEL_MSGVERM_NOCASE,
+    ACCEL_MDSVERM,
+    ACCEL_MDSVERM_NOCASE,
+    ACCEL_MDSGVERM,
+    ACCEL_MDSGVERM_NOCASE,
+    /* multibyte shuftis */
+    ACCEL_MLSHUFTI,
+    ACCEL_MLGSHUFTI,
+    ACCEL_MSSHUFTI,
+    ACCEL_MSGSHUFTI,
+    ACCEL_MDSSHUFTI,
+    ACCEL_MDSGSHUFTI,
+    /* multibyte truffles */
+    ACCEL_MLTRUFFLE,
+    ACCEL_MLGTRUFFLE,
+    ACCEL_MSTRUFFLE,
+    ACCEL_MSGTRUFFLE,
+    ACCEL_MDSTRUFFLE,
+    ACCEL_MDSGTRUFFLE,
+    /* masked dverm */
+    ACCEL_DVERM_MASKED,
+
 };
 
 /** \brief Structure for accel framework. */
@@ -80,7 +110,22 @@ union AccelAux {
         u8 offset;
         u8 c1; // uppercase if nocase
         u8 c2; // uppercase if nocase
+        u8 m1; // masked variant
+        u8 m2; // masked variant
     } dverm;
+    struct {
+        u8 accel_type;
+        u8 offset;
+        u8 c; // uppercase if nocase
+        u8 len;
+    } mverm;
+    struct {
+        u8 accel_type;
+        u8 offset;
+        u8 c; // uppercase if nocase
+        u8 len1;
+        u8 len2;
+    } mdverm;
     struct {
         u8 accel_type;
         u8 offset;
@@ -95,12 +140,42 @@ union AccelAux {
         m128 lo2;
         m128 hi2;
     } dshufti;
+    struct {
+        u8 accel_type;
+        u8 offset;
+        m128 lo;
+        m128 hi;
+        u8 len;
+    } mshufti;
+    struct {
+        u8 accel_type;
+        u8 offset;
+        m128 lo;
+        m128 hi;
+        u8 len1;
+        u8 len2;
+    } mdshufti;
     struct {
         u8 accel_type;
         u8 offset;
         m128 mask1;
         m128 mask2;
     } truffle;
+    struct {
+        u8 accel_type;
+        u8 offset;
+        m128 mask1;
+        m128 mask2;
+        u8 len;
+    } mtruffle;
+    struct {
+        u8 accel_type;
+        u8 offset;
+        m128 mask1;
+        m128 mask2;
+        u8 len1;
+        u8 len2;
+    } mdtruffle;
 };
 
 /**
diff --git a/src/nfa/accel_dump.cpp b/src/nfa/accel_dump.cpp
index 40c9c653..6e2b8f41 100644
--- a/src/nfa/accel_dump.cpp
+++ b/src/nfa/accel_dump.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -37,16 +37,21 @@
 #include "shufticompile.h"
 #include "trufflecompile.h"
 #include "ue2common.h"
+#include "util/bitutils.h"
 #include "util/charreach.h"
 #include "util/dump_charclass.h"
 #include "util/dump_mask.h"
+#include "util/simd_utils.h"
 
 #include <cstdio>
+#include <vector>
 
 #ifndef DUMP_SUPPORT
 #error No dump support!
 #endif
 
+using namespace std;
+
 namespace ue2 {
 
 static
@@ -62,6 +67,8 @@ const char *accelName(u8 accel_type) {
         return "double-vermicelli";
     case ACCEL_DVERM_NOCASE:
         return "double-vermicelli nocase";
+    case ACCEL_DVERM_MASKED:
+        return "double-vermicelli masked";
     case ACCEL_RVERM:
         return "reverse vermicelli";
     case ACCEL_RVERM_NOCASE:
@@ -86,11 +93,144 @@ const char *accelName(u8 accel_type) {
         return "truffle";
     case ACCEL_RED_TAPE:
         return "red tape";
+    case ACCEL_MLVERM:
+        return "multibyte long vermicelli";
+    case ACCEL_MLVERM_NOCASE:
+        return "multibyte long vermicelli nocase";
+    case ACCEL_MLGVERM:
+        return "multibyte long-grab vermicelli";
+    case ACCEL_MLGVERM_NOCASE:
+        return "multibyte long-grab vermicelli nocase";
+    case ACCEL_MSVERM:
+        return "multibyte shift vermicelli";
+    case ACCEL_MSVERM_NOCASE:
+        return "multibyte shift vermicelli nocase";
+    case ACCEL_MSGVERM:
+        return "multibyte shift-grab vermicelli";
+    case ACCEL_MSGVERM_NOCASE:
+        return "multibyte shift-grab vermicelli nocase";
+    case ACCEL_MDSVERM:
+        return "multibyte doubleshift vermicelli";
+    case ACCEL_MDSVERM_NOCASE:
+        return "multibyte doubleshift vermicelli nocase";
+    case ACCEL_MDSGVERM:
+        return "multibyte doubleshift-grab vermicelli";
+    case ACCEL_MDSGVERM_NOCASE:
+        return "multibyte doubleshift-grab vermicelli nocase";
+    case ACCEL_MLSHUFTI:
+        return "multibyte long shufti";
+    case ACCEL_MLGSHUFTI:
+        return "multibyte long-grab shufti";
+    case ACCEL_MSSHUFTI:
+        return "multibyte shift shufti";
+    case ACCEL_MSGSHUFTI:
+        return "multibyte shift-grab shufti";
+    case ACCEL_MDSSHUFTI:
+        return "multibyte doubleshift shufti";
+    case ACCEL_MDSGSHUFTI:
+        return "multibyte doubleshift-grab shufti";
+    case ACCEL_MLTRUFFLE:
+        return "multibyte long truffle";
+    case ACCEL_MLGTRUFFLE:
+        return "multibyte long-grab truffle";
+    case ACCEL_MSTRUFFLE:
+        return "multibyte shift truffle";
+    case ACCEL_MSGTRUFFLE:
+        return "multibyte shift-grab truffle";
+    case ACCEL_MDSTRUFFLE:
+        return "multibyte doubleshift truffle";
+    case ACCEL_MDSGTRUFFLE:
+        return "multibyte doubleshift-grab truffle";
     default:
         return "unknown!";
     }
 }
 
+static
+void dumpShuftiCharReach(FILE *f, const m128 &lo, const m128 &hi) {
+    CharReach cr = shufti2cr(lo, hi);
+    fprintf(f, "count %zu class %s\n", cr.count(),
+            describeClass(cr).c_str());
+}
+
+static
+vector<CharReach> shufti2cr_array(const m128 lo_in, const m128 hi_in) {
+    const u8 *lo = (const u8 *)&lo_in;
+    const u8 *hi = (const u8 *)&hi_in;
+    vector<CharReach> crs(8);
+    for (u32 i = 0; i < 256; i++) {
+        u32 combined = lo[(u8)i & 0xf] & hi[(u8)i >> 4];
+        while (combined) {
+            u32 j = findAndClearLSB_32(&combined);
+            crs.at(j).set(i);
+        }
+    }
+    return crs;
+}
+
+static
+void dumpDShuftiCharReach(FILE *f, const m128 &lo1, const m128 &hi1,
+                                   const m128 &lo2, const m128 &hi2) {
+    vector<CharReach> cr1 = shufti2cr_array(not128(lo1), not128(hi1));
+    vector<CharReach> cr2 = shufti2cr_array(not128(lo2), not128(hi2));
+    map<CharReach, set<u32> > cr1_group;
+    assert(cr1.size() == 8 && cr2.size() == 8);
+    for (u32 i = 0; i < 8; i++) {
+        if (!cr1[i].any()) {
+            continue;
+        }
+        cr1_group[cr1[i]].insert(i);
+    }
+    map<CharReach, CharReach> rev;
+    for (const auto &e : cr1_group) {
+        CharReach rhs;
+        for (u32 r : e.second) {
+            rhs |= cr2.at(r);
+        }
+
+        rev[rhs] |= e.first;
+    }
+    fprintf(f, "escapes: {");
+    for (auto it = rev.begin(); it != rev.end(); ++it) {
+        const auto &e = *it;
+        if (it != rev.begin()) {
+            fprintf(f, ", ");
+        }
+
+        if (e.first.all()) {
+            fprintf(f, "%s", describeClass(e.second).c_str());
+        } else {
+            fprintf(f, "%s%s", describeClass(e.second).c_str(),
+                    describeClass(e.first).c_str());
+        }
+    }
+    fprintf(f, "}\n");
+}
+
+static
+void dumpShuftiMasks(FILE *f, const m128 &lo, const m128 &hi) {
+    fprintf(f, "lo %s\n",
+            dumpMask((const u8 *)&lo, 128).c_str());
+    fprintf(f, "hi %s\n",
+            dumpMask((const u8 *)&hi, 128).c_str());
+}
+
+static
+void dumpTruffleCharReach(FILE *f, const m128 &hiset, const m128 &hiclear) {
+    CharReach cr = truffle2cr(hiset, hiclear);
+    fprintf(f, "count %zu class %s\n", cr.count(),
+            describeClass(cr).c_str());
+}
+
+static
+void dumpTruffleMasks(FILE *f, const m128 &hiset, const m128 &hiclear) {
+    fprintf(f, "lo %s\n",
+            dumpMask((const u8 *)&hiset, 128).c_str());
+    fprintf(f, "hi %s\n",
+            dumpMask((const u8 *)&hiclear, 128).c_str());
+}
+
+
 void dumpAccelInfo(FILE *f, const AccelAux &accel) {
     fprintf(f, " %s", accelName(accel.accel_type));
     if (accel.generic.offset) {
@@ -110,39 +250,76 @@ void dumpAccelInfo(FILE *f, const AccelAux &accel) {
     case ACCEL_RDVERM_NOCASE:
         fprintf(f, " [\\x%02hhx\\x%02hhx]\n", accel.dverm.c1, accel.dverm.c2);
         break;
+    case ACCEL_DVERM_MASKED:
+        fprintf(f, " [\\x%02hhx\\x%02hhx] & [\\x%02hhx\\x%02hhx]\n",
+                accel.dverm.c1, accel.dverm.c2, accel.dverm.m1, accel.dverm.m2);
+        break;
     case ACCEL_SHUFTI: {
         fprintf(f, "\n");
-        fprintf(f, "lo %s\n",
-                dumpMask((const u8 *)&accel.shufti.lo, 128).c_str());
-        fprintf(f, "hi %s\n",
-                dumpMask((const u8 *)&accel.shufti.hi, 128).c_str());
-        CharReach cr = shufti2cr(accel.shufti.lo, accel.shufti.hi);
-        fprintf(f, "count %zu class %s\n", cr.count(),
-                describeClass(cr).c_str());
+        dumpShuftiMasks(f, accel.shufti.lo, accel.shufti.hi);
+        dumpShuftiCharReach(f, accel.shufti.lo, accel.shufti.hi);
         break;
     }
     case ACCEL_DSHUFTI:
         fprintf(f, "\n");
-        fprintf(f, "lo1 %s\n",
-                dumpMask((const u8 *)&accel.dshufti.lo1, 128).c_str());
-        fprintf(f, "hi1 %s\n",
-                dumpMask((const u8 *)&accel.dshufti.hi1, 128).c_str());
-        fprintf(f, "lo2 %s\n",
-                dumpMask((const u8 *)&accel.dshufti.lo2, 128).c_str());
-        fprintf(f, "hi2 %s\n",
-                dumpMask((const u8 *)&accel.dshufti.hi2, 128).c_str());
+        fprintf(f, "mask 1\n");
+        dumpShuftiMasks(f, accel.dshufti.lo1, accel.dshufti.hi1);
+        fprintf(f, "mask 2\n");
+        dumpShuftiMasks(f, accel.dshufti.lo2, accel.dshufti.hi2);
+        dumpDShuftiCharReach(f, accel.dshufti.lo1, accel.dshufti.hi1,
+                             accel.dshufti.lo2, accel.dshufti.hi2);
         break;
     case ACCEL_TRUFFLE: {
         fprintf(f, "\n");
-        fprintf(f, "lo %s\n",
-                dumpMask((const u8 *)&accel.truffle.mask1, 128).c_str());
-        fprintf(f, "hi %s\n",
-                dumpMask((const u8 *)&accel.truffle.mask2, 128).c_str());
-        CharReach cr = truffle2cr(accel.truffle.mask1, accel.truffle.mask2);
-        fprintf(f, "count %zu class %s\n", cr.count(),
-                describeClass(cr).c_str());
+        dumpTruffleMasks(f, accel.truffle.mask1, accel.truffle.mask2);
+        dumpTruffleCharReach(f, accel.truffle.mask1, accel.truffle.mask2);
         break;
     }
+    case ACCEL_MLVERM:
+    case ACCEL_MLVERM_NOCASE:
+    case ACCEL_MLGVERM:
+    case ACCEL_MLGVERM_NOCASE:
+    case ACCEL_MSVERM:
+    case ACCEL_MSVERM_NOCASE:
+    case ACCEL_MSGVERM:
+    case ACCEL_MSGVERM_NOCASE:
+        fprintf(f, " [\\x%02hhx] len:%u\n", accel.mverm.c, accel.mverm.len);
+        break;
+    case ACCEL_MDSVERM:
+    case ACCEL_MDSVERM_NOCASE:
+    case ACCEL_MDSGVERM:
+    case ACCEL_MDSGVERM_NOCASE:
+        fprintf(f, " [\\x%02hhx] len1:%u len2:%u\n", accel.mdverm.c, accel.mdverm.len1,
+                accel.mdverm.len2);
+        break;
+    case ACCEL_MLSHUFTI:
+    case ACCEL_MLGSHUFTI:
+    case ACCEL_MSSHUFTI:
+    case ACCEL_MSGSHUFTI:
+        fprintf(f, " len:%u\n", accel.mshufti.len);
+        dumpShuftiMasks(f, accel.mshufti.lo, accel.mshufti.hi);
+        dumpShuftiCharReach(f, accel.mshufti.lo, accel.mshufti.hi);
+        break;
+    case ACCEL_MDSSHUFTI:
+    case ACCEL_MDSGSHUFTI:
+        fprintf(f, " len1:%u len2:%u\n", accel.mdshufti.len1, accel.mdshufti.len2);
+        dumpShuftiMasks(f, accel.mdshufti.lo, accel.mdshufti.hi);
+        dumpShuftiCharReach(f, accel.mdshufti.lo, accel.mdshufti.hi);
+        break;
+    case ACCEL_MLTRUFFLE:
+    case ACCEL_MLGTRUFFLE:
+    case ACCEL_MSTRUFFLE:
+    case ACCEL_MSGTRUFFLE:
+        fprintf(f, " len:%u\n", accel.mtruffle.len);
+        dumpTruffleMasks(f, accel.mtruffle.mask1, accel.mtruffle.mask2);
+        dumpTruffleCharReach(f, accel.mtruffle.mask1, accel.mtruffle.mask2);
+        break;
+    case ACCEL_MDSTRUFFLE:
+    case ACCEL_MDSGTRUFFLE:
+        fprintf(f, " len1:%u len2:%u\n", accel.mdtruffle.len1, accel.mdtruffle.len2);
+        dumpTruffleMasks(f, accel.mdtruffle.mask1, accel.mdtruffle.mask2);
+        dumpTruffleCharReach(f, accel.mdtruffle.mask1, accel.mdtruffle.mask2);
+        break;
     default:
         fprintf(f, "\n");
         break;
diff --git a/src/nfa/accelcompile.cpp b/src/nfa/accelcompile.cpp
index 2a22716a..75960dda 100644
--- a/src/nfa/accelcompile.cpp
+++ b/src/nfa/accelcompile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -94,6 +94,47 @@ void buildAccelSingle(const AccelInfo &info, AccelAux *aux) {
     DEBUG_PRINTF("unable to accelerate case with %zu outs\n", outs);
 }
 
+bool buildDvermMask(const flat_set<pair<u8, u8>> &escape_set, u8 *m1_out,
+                    u8 *m2_out) {
+    u8 a1 = 0xff;
+    u8 a2 = 0xff;
+    u8 b1 = 0xff;
+    u8 b2 = 0xff;
+
+    for (const auto &e : escape_set) {
+        DEBUG_PRINTF("%0hhx %0hhx\n", e.first, e.second);
+        a1 &= e.first;
+        b1 &= ~e.first;
+        a2 &= e.second;
+        b2 &= ~e.second;
+    }
+
+    u8 m1 = a1 | b1;
+    u8 m2 = a2 | b2;
+
+    u32 holes1 = 8 - popcount32(m1);
+    u32 holes2 = 8 - popcount32(m2);
+
+    DEBUG_PRINTF("aaaa %0hhx %0hhx\n", a1, a2);
+    DEBUG_PRINTF("bbbb %0hhx %0hhx\n", b1, b2);
+    DEBUG_PRINTF("mask %0hhx %0hhx\n", m1, m2);
+
+    assert(holes1 <= 8 && holes2 <= 8);
+    assert(escape_set.size() <= 1U << (holes1 + holes2));
+    if (escape_set.size() != 1U << (holes1 + holes2)) {
+        return false;
+    }
+
+    if (m1_out) {
+        *m1_out = m1;
+    }
+    if (m2_out) {
+        *m2_out = m2;
+    }
+
+    return true;
+}
+
 static
 bool isCaselessDouble(const flat_set<pair<u8, u8>> &stop) {
     // test for vector containing <A,Z> <A,z> <a,Z> <a,z>
@@ -149,17 +190,31 @@ void buildAccelDouble(const AccelInfo &info, AccelAux *aux) {
         return;
     }
 
-    if (outs1 + outs2 <= 8) {
-        if (outs1 < outs2 && outs1 <= 2) { // Heuristic from UE-438.
-            DEBUG_PRINTF("building double-shufti for %zu one-byte and %zu"
-                         " two-byte literals\n", outs1, outs2);
-            aux->accel_type = ACCEL_DSHUFTI;
-            aux->dshufti.offset = offset;
-            shuftiBuildDoubleMasks(info.double_stop1, info.double_stop2,
-                                   &aux->dshufti.lo1,
-                                   &aux->dshufti.hi1,
-                                   &aux->dshufti.lo2,
-                                   &aux->dshufti.hi2);
+    if (outs1 == 0) {
+        u8 m1;
+        u8 m2;
+
+        if (buildDvermMask(info.double_stop2, &m1, &m2)) {
+            aux->accel_type = ACCEL_DVERM_MASKED;
+            aux->dverm.offset = offset;
+            aux->dverm.c1 = info.double_stop2.begin()->first & m1;
+            aux->dverm.c2 = info.double_stop2.begin()->second & m2;
+            aux->dverm.m1 = m1;
+            aux->dverm.m2 = m2;
+            DEBUG_PRINTF("building maskeddouble-vermicelli for 0x%02hhx%02hhx\n",
+                         aux->dverm.c1, aux->dverm.c2);
+            return;
+        }
+    }
+
+    if (outs1 < outs2 && outs1 <= 2) { // Heuristic from UE-438.
+        DEBUG_PRINTF("building double-shufti for %zu one-byte and %zu"
+                     " two-byte literals\n", outs1, outs2);
+        aux->accel_type = ACCEL_DSHUFTI;
+        aux->dshufti.offset = offset;
+        if (shuftiBuildDoubleMasks(info.double_stop1, info.double_stop2,
+                                   &aux->dshufti.lo1, &aux->dshufti.hi1,
+                                   &aux->dshufti.lo2, &aux->dshufti.hi2)) {
             return;
         }
     }
@@ -169,13 +224,285 @@ void buildAccelDouble(const AccelInfo &info, AccelAux *aux) {
     aux->accel_type = ACCEL_NONE;
 }
 
+static
+void buildAccelMulti(const AccelInfo &info, AccelAux *aux) {
+    if (info.ma_type == MultibyteAccelInfo::MAT_NONE) {
+        DEBUG_PRINTF("no multimatch for us :(");
+        return;
+    }
+
+    u32 offset = info.multiaccel_offset;
+    const CharReach &stops = info.multiaccel_stops;
+
+    assert(aux->accel_type == ACCEL_NONE);
+    if (stops.all()) {
+        return;
+    }
+
+    size_t outs = stops.count();
+    DEBUG_PRINTF("%zu outs\n", outs);
+    assert(outs && outs < 256);
+
+    switch (info.ma_type) {
+    case MultibyteAccelInfo::MAT_LONG:
+        if (outs == 1) {
+            aux->accel_type = ACCEL_MLVERM;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first();
+            aux->mverm.len = info.ma_len1;
+            DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c);
+            return;
+        }
+        if (outs == 2 && stops.isCaselessChar()) {
+            aux->accel_type = ACCEL_MLVERM_NOCASE;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first() & CASE_CLEAR;
+            aux->mverm.len = info.ma_len1;
+            DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n",
+                         aux->verm.c);
+            return;
+        }
+        break;
+    case MultibyteAccelInfo::MAT_LONGGRAB:
+        if (outs == 1) {
+            aux->accel_type = ACCEL_MLGVERM;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first();
+            aux->mverm.len = info.ma_len1;
+            DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c);
+            return;
+        }
+        if (outs == 2 && stops.isCaselessChar()) {
+            aux->accel_type = ACCEL_MLGVERM_NOCASE;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first() & CASE_CLEAR;
+            aux->mverm.len = info.ma_len1;
+            DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n",
+                         aux->verm.c);
+            return;
+        }
+        break;
+    case MultibyteAccelInfo::MAT_SHIFT:
+        if (outs == 1) {
+            aux->accel_type = ACCEL_MSVERM;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first();
+            aux->mverm.len = info.ma_len1;
+            DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c);
+            return;
+        }
+        if (outs == 2 && stops.isCaselessChar()) {
+            aux->accel_type = ACCEL_MSVERM_NOCASE;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first() & CASE_CLEAR;
+            aux->mverm.len = info.ma_len1;
+            DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n",
+                         aux->verm.c);
+            return;
+        }
+        break;
+    case MultibyteAccelInfo::MAT_SHIFTGRAB:
+        if (outs == 1) {
+            aux->accel_type = ACCEL_MSGVERM;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first();
+            aux->mverm.len = info.ma_len1;
+            DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c);
+            return;
+        }
+        if (outs == 2 && stops.isCaselessChar()) {
+            aux->accel_type = ACCEL_MSGVERM_NOCASE;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first() & CASE_CLEAR;
+            aux->mverm.len = info.ma_len1;
+            DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n",
+                         aux->verm.c);
+            return;
+        }
+        break;
+    case MultibyteAccelInfo::MAT_DSHIFT:
+        if (outs == 1) {
+            aux->accel_type = ACCEL_MDSVERM;
+            aux->mdverm.offset = offset;
+            aux->mdverm.c = stops.find_first();
+            aux->mdverm.len1 = info.ma_len1;
+            aux->mdverm.len2 = info.ma_len2;
+            DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c);
+            return;
+        }
+        if (outs == 2 && stops.isCaselessChar()) {
+            aux->accel_type = ACCEL_MDSVERM_NOCASE;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first() & CASE_CLEAR;
+            aux->mdverm.len1 = info.ma_len1;
+            aux->mdverm.len2 = info.ma_len2;
+            DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n",
+                         aux->verm.c);
+            return;
+        }
+        break;
+    case MultibyteAccelInfo::MAT_DSHIFTGRAB:
+        if (outs == 1) {
+            aux->accel_type = ACCEL_MDSGVERM;
+            aux->mdverm.offset = offset;
+            aux->mdverm.c = stops.find_first();
+            aux->mdverm.len1 = info.ma_len1;
+            aux->mdverm.len2 = info.ma_len2;
+            DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c);
+            return;
+        }
+        if (outs == 2 && stops.isCaselessChar()) {
+            aux->accel_type = ACCEL_MDSGVERM_NOCASE;
+            aux->mverm.offset = offset;
+            aux->mverm.c = stops.find_first() & CASE_CLEAR;
+            aux->mdverm.len1 = info.ma_len1;
+            aux->mdverm.len2 = info.ma_len2;
+            DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n",
+                         aux->verm.c);
+            return;
+        }
+        break;
+    default:
+        // shouldn't happen
+        assert(0);
+        return;
+    }
+
+    DEBUG_PRINTF("attempting shufti for %zu chars\n", outs);
+
+    switch (info.ma_type) {
+    case MultibyteAccelInfo::MAT_LONG:
+        if (shuftiBuildMasks(stops, &aux->mshufti.lo,
+                &aux->mshufti.hi) == -1) {
+            break;
+        }
+        aux->accel_type = ACCEL_MLSHUFTI;
+        aux->mshufti.offset = offset;
+        aux->mshufti.len = info.ma_len1;
+        return;
+    case MultibyteAccelInfo::MAT_LONGGRAB:
+        if (shuftiBuildMasks(stops, &aux->mshufti.lo,
+                &aux->mshufti.hi) == -1) {
+            break;
+        }
+        aux->accel_type = ACCEL_MLGSHUFTI;
+        aux->mshufti.offset = offset;
+        aux->mshufti.len = info.ma_len1;
+        return;
+    case MultibyteAccelInfo::MAT_SHIFT:
+        if (shuftiBuildMasks(stops, &aux->mshufti.lo,
+                &aux->mshufti.hi) == -1) {
+            break;
+        }
+        aux->accel_type = ACCEL_MSSHUFTI;
+        aux->mshufti.offset = offset;
+        aux->mshufti.len = info.ma_len1;
+        return;
+    case MultibyteAccelInfo::MAT_SHIFTGRAB:
+        if (shuftiBuildMasks(stops, &aux->mshufti.lo,
+                &aux->mshufti.hi) == -1) {
+            break;
+        }
+        aux->accel_type = ACCEL_MSGSHUFTI;
+        aux->mshufti.offset = offset;
+        aux->mshufti.len = info.ma_len1;
+        return;
+    case MultibyteAccelInfo::MAT_DSHIFT:
+        if (shuftiBuildMasks(stops, &aux->mdshufti.lo,
+                &aux->mdshufti.hi) == -1) {
+            break;
+        }
+        aux->accel_type = ACCEL_MDSSHUFTI;
+        aux->mdshufti.offset = offset;
+        aux->mdshufti.len1 = info.ma_len1;
+        aux->mdshufti.len2 = info.ma_len2;
+        return;
+    case MultibyteAccelInfo::MAT_DSHIFTGRAB:
+        if (shuftiBuildMasks(stops, &aux->mdshufti.lo,
+                &aux->mdshufti.hi) == -1) {
+            break;
+        }
+        aux->accel_type = ACCEL_MDSGSHUFTI;
+        aux->mdshufti.offset = offset;
+        aux->mdshufti.len1 = info.ma_len1;
+        aux->mdshufti.len2 = info.ma_len2;
+        return;
+    default:
+        // shouldn't happen
+        assert(0);
+        return;
+    }
+    DEBUG_PRINTF("shufti build failed, falling through\n");
+
+    if (outs <= ACCEL_MAX_STOP_CHAR) {
+        DEBUG_PRINTF("building Truffle for %zu chars\n", outs);
+        switch (info.ma_type) {
+        case MultibyteAccelInfo::MAT_LONG:
+            aux->accel_type = ACCEL_MLTRUFFLE;
+            aux->mtruffle.offset = offset;
+            aux->mtruffle.len = info.ma_len1;
+            truffleBuildMasks(stops, &aux->mtruffle.mask1,
+                              &aux->mtruffle.mask2);
+            break;
+        case MultibyteAccelInfo::MAT_LONGGRAB:
+            aux->accel_type = ACCEL_MLGTRUFFLE;
+            aux->mtruffle.offset = offset;
+            aux->mtruffle.len = info.ma_len1;
+            truffleBuildMasks(stops, &aux->mtruffle.mask1,
+                              &aux->mtruffle.mask2);
+            break;
+        case MultibyteAccelInfo::MAT_SHIFT:
+            aux->accel_type = ACCEL_MSTRUFFLE;
+            aux->mtruffle.offset = offset;
+            aux->mtruffle.len = info.ma_len1;
+            truffleBuildMasks(stops, &aux->mtruffle.mask1,
+                              &aux->mtruffle.mask2);
+            break;
+        case MultibyteAccelInfo::MAT_SHIFTGRAB:
+            aux->accel_type = ACCEL_MSGTRUFFLE;
+            aux->mtruffle.offset = offset;
+            aux->mtruffle.len = info.ma_len1;
+            truffleBuildMasks(stops, &aux->mtruffle.mask1,
+                              &aux->mtruffle.mask2);
+            break;
+        case MultibyteAccelInfo::MAT_DSHIFT:
+            aux->accel_type = ACCEL_MDSTRUFFLE;
+            aux->mdtruffle.offset = offset;
+            aux->mdtruffle.len1 = info.ma_len1;
+            aux->mdtruffle.len2 = info.ma_len2;
+            truffleBuildMasks(stops, &aux->mtruffle.mask1,
+                              &aux->mdtruffle.mask2);
+            break;
+        case MultibyteAccelInfo::MAT_DSHIFTGRAB:
+            aux->accel_type = ACCEL_MDSGTRUFFLE;
+            aux->mdtruffle.offset = offset;
+            aux->mdtruffle.len1 = info.ma_len1;
+            aux->mdtruffle.len2 = info.ma_len2;
+            truffleBuildMasks(stops, &aux->mtruffle.mask1,
+                              &aux->mdtruffle.mask2);
+            break;
+        default:
+            // shouldn't happen
+            assert(0);
+            return;
+        }
+        return;
+    }
+
+    DEBUG_PRINTF("unable to accelerate multibyte case with %zu outs\n", outs);
+}
+
 bool buildAccelAux(const AccelInfo &info, AccelAux *aux) {
     assert(aux->accel_type == ACCEL_NONE);
     if (info.single_stops.none()) {
         DEBUG_PRINTF("picked red tape\n");
         aux->accel_type = ACCEL_RED_TAPE;
         aux->generic.offset = info.single_offset;
-    } else {
+    }
+    if (aux->accel_type == ACCEL_NONE) {
+        buildAccelMulti(info, aux);
+    }
+    if (aux->accel_type == ACCEL_NONE) {
         buildAccelDouble(info, aux);
     }
     if (aux->accel_type == ACCEL_NONE) {
diff --git a/src/nfa/accelcompile.h b/src/nfa/accelcompile.h
index 12af559c..9b30146c 100644
--- a/src/nfa/accelcompile.h
+++ b/src/nfa/accelcompile.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -37,9 +37,30 @@ union AccelAux;
 
 namespace ue2 {
 
+struct MultibyteAccelInfo {
+    /* multibyte accel schemes, ordered by strength */
+    enum multiaccel_type {
+        MAT_SHIFT,
+        MAT_SHIFTGRAB,
+        MAT_DSHIFT,
+        MAT_DSHIFTGRAB,
+        MAT_LONG,
+        MAT_LONGGRAB,
+        MAT_MAX,
+        MAT_NONE = MAT_MAX
+    };
+    CharReach cr;
+    u32 offset = 0;
+    u32 len1 = 0;
+    u32 len2 = 0;
+    multiaccel_type type = MAT_NONE;
+};
+
 struct AccelInfo {
     AccelInfo() : single_offset(0U), double_offset(0U),
-                  single_stops(CharReach::dot()) {}
+                  single_stops(CharReach::dot()),
+                  multiaccel_offset(0), ma_len1(0), ma_len2(0),
+                  ma_type(MultibyteAccelInfo::MAT_NONE) {}
     u32 single_offset; /**< offset correction to apply to single schemes */
     u32 double_offset; /**< offset correction to apply to double schemes */
     CharReach double_stop1;  /**<  single-byte accel stop literals for double
@@ -47,10 +68,19 @@ struct AccelInfo {
     flat_set<std::pair<u8, u8>> double_stop2; /**< double-byte accel stop
                                                * literals */
     CharReach single_stops; /**< escapes for single byte acceleration */
+    u32 multiaccel_offset; /**< offset correction to apply to multibyte schemes */
+    CharReach multiaccel_stops; /**< escapes for multibyte acceleration */
+    u32 ma_len1; /**< multiaccel len1 */
+    u32 ma_len2; /**< multiaccel len2 */
+    MultibyteAccelInfo::multiaccel_type ma_type; /**< multiaccel type */
 };
 
 bool buildAccelAux(const AccelInfo &info, AccelAux *aux);
 
+/* returns true is the escape set can be handled with a masked double_verm */
+bool buildDvermMask(const flat_set<std::pair<u8, u8>> &escape_set,
+                    u8 *m1_out = nullptr, u8 *m2_out = nullptr);
+
 } // namespace ue2
 
 #endif
diff --git a/src/nfa/castle.c b/src/nfa/castle.c
index 66e0ded6..13a44a97 100644
--- a/src/nfa/castle.c
+++ b/src/nfa/castle.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -96,7 +96,8 @@ char subCastleReportCurrent(const struct Castle *c, struct mq *q,
         repeatHasMatch(info, rctrl, rstate, offset);
     DEBUG_PRINTF("repeatHasMatch returned %d\n", match);
     if (match == REPEAT_MATCH) {
-        DEBUG_PRINTF("firing match at %llu for sub %u\n", offset, subIdx);
+        DEBUG_PRINTF("firing match at %llu for sub %u, report %u\n", offset,
+                     subIdx, sub->report);
         if (q->cb(offset, sub->report, q->context) == MO_HALT_MATCHING) {
             return MO_HALT_MATCHING;
         }
@@ -111,17 +112,22 @@ int castleReportCurrent(const struct Castle *c, struct mq *q) {
     DEBUG_PRINTF("offset=%llu\n", offset);
 
     if (c->exclusive) {
-        const u32 activeIdx = partial_load_u32(q->streamState,
-                                               c->activeIdxSize);
-        DEBUG_PRINTF("subcastle %u\n", activeIdx);
-        if (activeIdx < c->numRepeats && subCastleReportCurrent(c, q,
-                offset, activeIdx) == MO_HALT_MATCHING) {
-            return MO_HALT_MATCHING;
+        u8 *active = (u8 *)q->streamState;
+        u8 *groups = active + c->groupIterOffset;
+        for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID);
+             i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) {
+            u8 *cur = active + i * c->activeIdxSize;
+            const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize);
+            DEBUG_PRINTF("subcastle %u\n", activeIdx);
+            if (subCastleReportCurrent(c, q,
+                    offset, activeIdx) == MO_HALT_MATCHING) {
+                return MO_HALT_MATCHING;
+            }
         }
     }
 
-    if (!c->pureExclusive) {
-        const u8 *active = (const u8 *)q->streamState + c->activeIdxSize;
+    if (c->exclusive != PURE_EXCLUSIVE) {
+        const u8 *active = (const u8 *)q->streamState + c->activeOffset;
         for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID);
              i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) {
             DEBUG_PRINTF("subcastle %u\n", i);
@@ -162,11 +168,18 @@ static really_inline
 char castleInAccept(const struct Castle *c, struct mq *q,
                     const ReportID report, const u64a offset) {
     DEBUG_PRINTF("offset=%llu\n", offset);
+     /* ignore when just catching up due to full queue */
+    if (report == MO_INVALID_IDX) {
+        return 0;
+    }
 
     if (c->exclusive) {
-        const u32 activeIdx = partial_load_u32(q->streamState,
-                                               c->activeIdxSize);
-        if (activeIdx < c->numRepeats) {
+        u8 *active = (u8 *)q->streamState;
+        u8 *groups = active + c->groupIterOffset;
+        for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID);
+             i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) {
+            u8 *cur = active + i * c->activeIdxSize;
+            const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize);
             DEBUG_PRINTF("subcastle %u\n", activeIdx);
             if (subCastleInAccept(c, q, report, offset, activeIdx)) {
                 return 1;
@@ -174,11 +187,10 @@ char castleInAccept(const struct Castle *c, struct mq *q,
         }
     }
 
-    if (!c->pureExclusive) {
-        const u8 *active = (const u8 *)q->streamState + c->activeIdxSize;
+    if (c->exclusive != PURE_EXCLUSIVE) {
+        const u8 *active = (const u8 *)q->streamState + c->activeOffset;
         for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID);
-             i != MMB_INVALID;
-             i = mmbit_iterate(active, c->numRepeats, i)) {
+             i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) {
             DEBUG_PRINTF("subcastle %u\n", i);
             if (subCastleInAccept(c, q, report, offset, i)) {
                 return 1;
@@ -193,7 +205,6 @@ static really_inline
 void subCastleDeactivateStaleSubs(const struct Castle *c, const u64a offset,
                                   void *full_state, void *stream_state,
                                   const u32 subIdx) {
-    u8 *active = (u8 *)stream_state;
     const struct SubCastle *sub = getSubCastle(c, subIdx);
     const struct RepeatInfo *info = getRepeatInfo(sub);
 
@@ -203,10 +214,13 @@ void subCastleDeactivateStaleSubs(const struct Castle *c, const u64a offset,
 
     if (repeatHasMatch(info, rctrl, rstate, offset) == REPEAT_STALE) {
         DEBUG_PRINTF("sub %u is stale at offset %llu\n", subIdx, offset);
-        if (sub->exclusive) {
-            partial_store_u32(stream_state, c->numRepeats, c->activeIdxSize);
+        if (sub->exclusiveId < c->numRepeats) {
+            u8 *active = (u8 *)stream_state;
+            u8 *groups = active + c->groupIterOffset;
+            mmbit_unset(groups, c->numGroups, sub->exclusiveId);
         } else {
-            mmbit_unset(active + c->activeIdxSize, c->numRepeats, subIdx);
+            u8 *active = (u8 *)stream_state + c->activeOffset;
+            mmbit_unset(active, c->numRepeats, subIdx);
         }
     }
 }
@@ -216,30 +230,47 @@ void castleDeactivateStaleSubs(const struct Castle *c, const u64a offset,
                                void *full_state, void *stream_state) {
     DEBUG_PRINTF("offset=%llu\n", offset);
 
+    if (!c->staleIterOffset) {
+        DEBUG_PRINTF("{no repeats can go stale}\n");
+        return; /* no subcastle can ever go stale */
+    }
+
     if (c->exclusive) {
-        const u32 activeIdx = partial_load_u32(stream_state, c->activeIdxSize);
-        if (activeIdx < c->numRepeats) {
+        u8 *active = (u8 *)stream_state;
+        u8 *groups = active + c->groupIterOffset;
+        for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID);
+             i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) {
+            u8 *cur = active + i * c->activeIdxSize;
+            const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize);
             DEBUG_PRINTF("subcastle %u\n", activeIdx);
             subCastleDeactivateStaleSubs(c, offset, full_state,
                                          stream_state, activeIdx);
         }
     }
 
-    if (!c->pureExclusive) {
-        const u8 *active = (const u8 *)stream_state + c->activeIdxSize;
-        for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID);
-             i != MMB_INVALID;
-             i = mmbit_iterate(active, c->numRepeats, i)) {
+    if (c->exclusive != PURE_EXCLUSIVE) {
+        const u8 *active = (const u8 *)stream_state + c->activeOffset;
+        const struct mmbit_sparse_iter *it
+            = (const void *)((const char *)c + c->staleIterOffset);
+
+        struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES];
+        u32 numRepeats = c->numRepeats;
+        u32 idx = 0;
+
+        u32 i = mmbit_sparse_iter_begin(active, numRepeats, &idx, it, si_state);
+        while(i != MMB_INVALID) {
             DEBUG_PRINTF("subcastle %u\n", i);
-            subCastleDeactivateStaleSubs(c, offset, full_state,
-                                         stream_state, i);
+            subCastleDeactivateStaleSubs(c, offset, full_state, stream_state, i);
+            i = mmbit_sparse_iter_next(active, numRepeats, i, &idx, it,
+                                       si_state);
         }
     }
 }
 
 static really_inline
 void castleProcessTop(const struct Castle *c, const u32 top, const u64a offset,
-                      void *full_state, void *stream_state) {
+                      void *full_state, void *stream_state,
+                      UNUSED char stale_checked) {
     assert(top < c->numRepeats);
 
     const struct SubCastle *sub = getSubCastle(c, top);
@@ -249,12 +280,20 @@ void castleProcessTop(const struct Castle *c, const u32 top, const u64a offset,
                    info->packedCtrlSize;
 
     char is_alive = 0;
-    if (sub->exclusive) {
-        const u32 activeIdx = partial_load_u32(stream_state, c->activeIdxSize);
-        is_alive = (activeIdx == top);
-        partial_store_u32(stream_state, top, c->activeIdxSize);
+    u8 *active = (u8 *)stream_state;
+    if (sub->exclusiveId < c->numRepeats) {
+        u8 *groups = active + c->groupIterOffset;
+        active += sub->exclusiveId * c->activeIdxSize;
+        if (mmbit_set(groups, c->numGroups, sub->exclusiveId)) {
+            const u32 activeIdx = partial_load_u32(active, c->activeIdxSize);
+            is_alive = (activeIdx == top);
+        }
+
+        if (!is_alive) {
+            partial_store_u32(active, top, c->activeIdxSize);
+        }
     } else {
-        u8 *active = (u8 *)stream_state + c->activeIdxSize;
+        active += c->activeOffset;
         is_alive = mmbit_set(active, c->numRepeats, top);
     }
 
@@ -263,8 +302,8 @@ void castleProcessTop(const struct Castle *c, const u32 top, const u64a offset,
     } else {
         DEBUG_PRINTF("repeat %u is already alive\n", top);
         // Caller should ensure we're not stale.
-        assert(repeatHasMatch(info, rctrl, rstate, offset) !=
-               REPEAT_STALE);
+        assert(!stale_checked
+               || repeatHasMatch(info, rctrl, rstate, offset) != REPEAT_STALE);
 
         // Ignore duplicate top events.
         u64a last = repeatLastTop(info, rctrl, rstate);
@@ -292,11 +331,11 @@ void subCastleFindMatch(const struct Castle *c, const u64a begin,
     u64a match = repeatNextMatch(info, rctrl, rstate, begin);
     if (match == 0) {
         DEBUG_PRINTF("no more matches for sub %u\n", subIdx);
-        if (sub->exclusive) {
-            partial_store_u32(stream_state, c->numRepeats,
-                                  c->activeIdxSize);
+        if (sub->exclusiveId < c->numRepeats) {
+            u8 *groups = (u8 *)stream_state + c->groupIterOffset;
+            mmbit_unset(groups, c->numGroups, sub->exclusiveId);
         } else {
-            u8 *active = (u8 *)stream_state + c->activeIdxSize;
+            u8 *active = (u8 *)stream_state + c->activeOffset;
             mmbit_unset(active, c->numRepeats, subIdx);
         }
         return;
@@ -329,16 +368,20 @@ char castleFindMatch(const struct Castle *c, const u64a begin, const u64a end,
     *mloc = 0;
 
     if (c->exclusive) {
-        const u32 activeIdx = partial_load_u32(stream_state, c->activeIdxSize);
-        if (activeIdx < c->numRepeats) {
+        u8 *active = (u8 *)stream_state;
+        u8 *groups = active + c->groupIterOffset;
+        for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID);
+             i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) {
+            u8 *cur = active + i * c->activeIdxSize;
+            const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize);
             DEBUG_PRINTF("subcastle %u\n", activeIdx);
             subCastleFindMatch(c, begin, end, full_state, stream_state, mloc,
                                &found, activeIdx);
         }
     }
 
-    if (!c->pureExclusive) {
-        u8 *active = (u8 *)stream_state + c->activeIdxSize;
+    if (c->exclusive != PURE_EXCLUSIVE) {
+        u8 *active = (u8 *)stream_state + c->activeOffset;
         for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID);
              i != MMB_INVALID;
              i = mmbit_iterate(active, c->numRepeats, i)) {
@@ -367,31 +410,38 @@ u64a subCastleNextMatch(const struct Castle *c, void *full_state,
     return repeatNextMatch(info, rctrl, rstate, loc);
 }
 
+static really_inline
+void set_matching(const struct Castle *c, const u64a match, u8 *active,
+                  u8 *matching, const u32 active_size, const u32 active_id,
+                  const u32 matching_id, u64a *offset, const u64a end) {
+    if (match == 0) {
+        DEBUG_PRINTF("no more matches\n");
+        mmbit_unset(active, active_size, active_id);
+    } else if (match > end) {
+        // If we had a local copy of the active mmbit, we could skip
+        // looking at this repeat again. But we don't, so we just move
+        // on.
+    } else if (match == *offset) {
+        mmbit_set(matching, c->numRepeats, matching_id);
+    } else if (match < *offset) {
+        // New minimum offset.
+        *offset = match;
+        mmbit_clear(matching, c->numRepeats);
+        mmbit_set(matching, c->numRepeats, matching_id);
+    }
+}
+
 static really_inline
 void subCastleMatchLoop(const struct Castle *c, void *full_state,
                         void *stream_state, const u64a end,
                         const u64a loc, u64a *offset) {
-    u8 *active = (u8 *)stream_state + c->activeIdxSize;
+    u8 *active = (u8 *)stream_state + c->activeOffset;
     u8 *matching = full_state;
-    mmbit_clear(matching, c->numRepeats);
     for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID);
          i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) {
         u64a match = subCastleNextMatch(c, full_state, stream_state, loc, i);
-        if (match == 0) {
-            DEBUG_PRINTF("no more matches\n");
-            mmbit_unset(active, c->numRepeats, i);
-        } else if (match > end) {
-            // If we had a local copy of the active mmbit, we could skip
-            // looking at this repeat again. But we don't, so we just move
-            // on.
-        } else if (match == *offset) {
-            mmbit_set(matching, c->numRepeats, i);
-        } else if (match < *offset) {
-            // New minimum offset.
-            *offset = match;
-            mmbit_clear(matching, c->numRepeats);
-            mmbit_set(matching, c->numRepeats, i);
-        }
+        set_matching(c, match, active, matching, c->numRepeats, i,
+                     i, offset, end);
     }
 }
 
@@ -434,61 +484,37 @@ char castleMatchLoop(const struct Castle *c, const u64a begin, const u64a end,
         // full_state (scratch).
 
         u64a offset = end; // min offset of next match
-        char found = 0;
         u32 activeIdx = 0;
+        mmbit_clear(matching, c->numRepeats);
         if (c->exclusive) {
-            activeIdx = partial_load_u32(stream_state, c->activeIdxSize);
-            if (activeIdx < c->numRepeats) {
-                u32 i = activeIdx;
-                DEBUG_PRINTF("subcastle %u\n", i);
+            u8 *active = (u8 *)stream_state;
+            u8 *groups = active + c->groupIterOffset;
+            for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID);
+                 i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) {
+                u8 *cur = active + i * c->activeIdxSize;
+                activeIdx = partial_load_u32(cur, c->activeIdxSize);
                 u64a match = subCastleNextMatch(c, full_state, stream_state,
-                                                loc, i);
-
-                if (match == 0) {
-                    DEBUG_PRINTF("no more matches\n");
-                    partial_store_u32(stream_state, c->numRepeats,
-                                      c->activeIdxSize);
-                } else if (match > end) {
-                    // If we had a local copy of the active mmbit, we could skip
-                    // looking at this repeat again. But we don't, so we just move
-                    // on.
-                } else if (match <= offset) {
-                    if (match < offset) {
-                        // New minimum offset.
-                        offset = match;
-                    }
-                    found = 1;
-                }
+                                                loc, activeIdx);
+                set_matching(c, match, groups, matching, c->numGroups, i,
+                             activeIdx, &offset, end);
             }
         }
 
-        const char hasMatch = found;
-        u64a newOffset = offset;
-        if (!c->pureExclusive) {
+        if (c->exclusive != PURE_EXCLUSIVE) {
             subCastleMatchLoop(c, full_state, stream_state,
-                               end, loc, &newOffset);
-
-            DEBUG_PRINTF("offset=%llu\n", newOffset);
-            if (mmbit_any(matching, c->numRepeats)) {
-                found = 1;
-                if (subCastleFireMatch(c, full_state, stream_state,
-                        cb, ctx, newOffset) == MO_HALT_MATCHING) {
-                    return MO_HALT_MATCHING;
-                }
-            }
+                               end, loc, &offset);
         }
-
-        if (!found) {
+        DEBUG_PRINTF("offset=%llu\n", offset);
+        if (!mmbit_any(matching, c->numRepeats)) {
+            DEBUG_PRINTF("no more matches\n");
             break;
-        } else if (hasMatch && offset == newOffset) {
-            const struct SubCastle *sub = getSubCastle(c, activeIdx);
-            DEBUG_PRINTF("firing match at %llu for sub %u\n", offset, activeIdx);
-            if (cb(offset, sub->report, ctx) == MO_HALT_MATCHING) {
-                DEBUG_PRINTF("caller told us to halt\n");
-                return MO_HALT_MATCHING;
-            }
         }
-        loc = newOffset;
+
+        if (subCastleFireMatch(c, full_state, stream_state,
+                cb, ctx, offset) == MO_HALT_MATCHING) {
+            return MO_HALT_MATCHING;
+        }
+        loc = offset;
     }
 
     return MO_CONTINUE_MATCHING;
@@ -547,7 +573,8 @@ char castleScanShufti(const struct Castle *c, const u8 *buf, const size_t begin,
 static really_inline
 char castleScanTruffle(const struct Castle *c, const u8 *buf, const size_t begin,
                       const size_t end, size_t *loc) {
-    const u8 *ptr = truffleExec(c->u.truffle.mask1, c->u.truffle.mask2, buf + begin, buf + end);
+    const u8 *ptr = truffleExec(c->u.truffle.mask1, c->u.truffle.mask2,
+                                buf + begin, buf + end);
     if (ptr == buf + end) {
         DEBUG_PRINTF("no escape found\n");
         return 0;
@@ -589,7 +616,103 @@ char castleScan(const struct Castle *c, const u8 *buf, const size_t begin,
 }
 
 static really_inline
-void castleHandleEvent(const struct Castle *c, struct mq *q, const u64a sp) {
+char castleRevScanVerm(const struct Castle *c, const u8 *buf,
+                       const size_t begin, const size_t end, size_t *loc) {
+    const u8 *ptr = rvermicelliExec(c->u.verm.c, 0, buf + begin, buf + end);
+    if (ptr == buf + begin - 1) {
+        DEBUG_PRINTF("no escape found\n");
+        return 0;
+    }
+
+    assert(loc);
+    assert(ptr >= buf && ptr < buf + end);
+    *loc = (size_t)(ptr - buf);
+    DEBUG_PRINTF("escape found at offset %zu\n", *loc);
+    return 1;
+}
+
+static really_inline
+char castleRevScanNVerm(const struct Castle *c, const u8 *buf,
+                        const size_t begin, const size_t end, size_t *loc) {
+    const u8 *ptr = rnvermicelliExec(c->u.verm.c, 0, buf + begin, buf + end);
+    if (ptr == buf + begin - 1) {
+        DEBUG_PRINTF("no escape found\n");
+        return 0;
+    }
+
+    assert(loc);
+    assert(ptr >= buf && ptr < buf + end);
+    *loc = (size_t)(ptr - buf);
+    DEBUG_PRINTF("escape found at offset %zu\n", *loc);
+    return 1;
+}
+
+static really_inline
+char castleRevScanShufti(const struct Castle *c, const u8 *buf,
+                         const size_t begin, const size_t end, size_t *loc) {
+    const m128 mask_lo = c->u.shuf.mask_lo;
+    const m128 mask_hi = c->u.shuf.mask_hi;
+    const u8 *ptr = rshuftiExec(mask_lo, mask_hi, buf + begin, buf + end);
+    if (ptr == buf + begin - 1) {
+        DEBUG_PRINTF("no escape found\n");
+        return 0;
+    }
+
+    assert(loc);
+    assert(ptr >= buf && ptr < buf + end);
+    *loc = (size_t)(ptr - buf);
+    DEBUG_PRINTF("escape found at offset %zu\n", *loc);
+    return 1;
+}
+
+static really_inline
+char castleRevScanTruffle(const struct Castle *c, const u8 *buf,
+                          const size_t begin, const size_t end, size_t *loc) {
+    const u8 *ptr = rtruffleExec(c->u.truffle.mask1, c->u.truffle.mask2,
+                                 buf + begin, buf + end);
+    if (ptr == buf + begin - 1) {
+        DEBUG_PRINTF("no escape found\n");
+        return 0;
+    }
+
+    assert(loc);
+    assert(ptr >= buf && ptr < buf + end);
+    *loc = (size_t)(ptr - buf);
+    DEBUG_PRINTF("escape found at offset %zu\n", *loc);
+    return 1;
+}
+
+static really_inline
+char castleRevScan(const struct Castle *c, const u8 *buf, const size_t begin,
+                const size_t end, size_t *loc) {
+    assert(begin <= end);
+    DEBUG_PRINTF("scanning backwards over (%zu,%zu]\n", begin, end);
+    if (begin == end) {
+        return 0;
+    }
+
+    switch (c->type) {
+    case CASTLE_DOT:
+        // Nothing can stop a dot scan!
+        return 0;
+    case CASTLE_VERM:
+        return castleRevScanVerm(c, buf, begin, end, loc);
+    case CASTLE_NVERM:
+        return castleRevScanNVerm(c, buf, begin, end, loc);
+    case CASTLE_SHUFTI:
+        return castleRevScanShufti(c, buf, begin, end, loc);
+    case CASTLE_TRUFFLE:
+        return castleRevScanTruffle(c, buf, begin, end, loc);
+    default:
+        DEBUG_PRINTF("unknown scan type!\n");
+        assert(0);
+        return 0;
+    }
+}
+
+static really_inline
+void castleHandleEvent(const struct Castle *c, struct mq *q, const u64a sp,
+                       char stale_checked) {
     const u32 event = q->items[q->cur].type;
     switch (event) {
     case MQE_TOP:
@@ -603,11 +726,24 @@ void castleHandleEvent(const struct Castle *c, struct mq *q, const u64a sp) {
         assert(event < MQE_INVALID);
         u32 top = event - MQE_TOP_FIRST;
         DEBUG_PRINTF("top %u at offset %llu\n", top, sp);
-        castleProcessTop(c, top, sp, q->state, q->streamState);
+        castleProcessTop(c, top, sp, q->state, q->streamState, stale_checked);
         break;
     }
 }
 
+static really_inline
+void clear_repeats(const struct Castle *c, const struct mq *q, u8 *active) {
+    DEBUG_PRINTF("clearing active repeats due to escape\n");
+    if (c->exclusive) {
+        u8 *groups = (u8 *)q->streamState + c->groupIterOffset;
+        mmbit_clear(groups, c->numGroups);
+    }
+
+    if (c->exclusive != PURE_EXCLUSIVE) {
+        mmbit_clear(active, c->numRepeats);
+    }
+}
+
 static really_inline
 char nfaExecCastle0_Q_i(const struct NFA *n, struct mq *q, s64a end,
                         enum MatchMode mode) {
@@ -630,7 +766,7 @@ char nfaExecCastle0_Q_i(const struct NFA *n, struct mq *q, s64a end,
         return 1;
     }
 
-    u8 *active = (u8 *)q->streamState + c->activeIdxSize; // active multibit
+    u8 *active = (u8 *)q->streamState + c->activeOffset;// active multibit
 
     assert(q->cur + 1 < q->end); // require at least two items
     assert(q_cur_type(q) == MQE_START);
@@ -644,14 +780,8 @@ char nfaExecCastle0_Q_i(const struct NFA *n, struct mq *q, s64a end,
 
         char found = 0;
         if (c->exclusive) {
-            const u32 activeIdx = partial_load_u32(q->streamState,
-                                                   c->activeIdxSize);
-            if (activeIdx < c->numRepeats) {
-                found = 1;
-            } else if (c->pureExclusive) {
-                DEBUG_PRINTF("castle is dead\n");
-                goto scan_done;
-            }
+            u8 *groups = (u8 *)q->streamState + c->groupIterOffset;
+            found = mmbit_any(groups, c->numGroups);
         }
 
         if (!found && !mmbit_any(active, c->numRepeats)) {
@@ -698,15 +828,7 @@ char nfaExecCastle0_Q_i(const struct NFA *n, struct mq *q, s64a end,
             }
 
             if (escape_found) {
-                DEBUG_PRINTF("clearing active repeats due to escape\n");
-                if (c->exclusive) {
-                    partial_store_u32(q->streamState, c->numRepeats,
-                                      c->activeIdxSize);
-                }
-
-                if (!c->pureExclusive) {
-                    mmbit_clear(active, c->numRepeats);
-                }
+                clear_repeats(c, q, active);
             }
         }
 
@@ -720,15 +842,14 @@ char nfaExecCastle0_Q_i(const struct NFA *n, struct mq *q, s64a end,
         }
 
         sp = q_cur_offset(q);
-        castleHandleEvent(c, q, sp);
+        castleHandleEvent(c, q, sp, 1);
         q->cur++;
     }
 
     if (c->exclusive) {
-        const u32 activeIdx = partial_load_u32(q->streamState,
-                                               c->activeIdxSize);
-        if (c->pureExclusive || activeIdx < c->numRepeats) {
-            return activeIdx < c->numRepeats;
+        u8 *groups = (u8 *)q->streamState + c->groupIterOffset;
+        if (mmbit_any_precise(groups, c->numGroups)) {
+            return 1;
         }
     }
 
@@ -745,28 +866,34 @@ char nfaExecCastle0_Q2(const struct NFA *n, struct mq *q, s64a end) {
     return nfaExecCastle0_Q_i(n, q, end, STOP_AT_MATCH);
 }
 
-static really_inline
-void castleStreamSilent(const struct Castle *c, u8 *active, const u8 *buf,
-                        size_t length) {
-    DEBUG_PRINTF("entry\n");
+static
+s64a castleLastKillLoc(const struct Castle *c, struct mq *q) {
+    assert(q_cur_type(q) == MQE_START);
+    assert(q_last_type(q) == MQE_END);
+    s64a sp = q_cur_loc(q);
+    s64a ep = q_last_loc(q);
 
-    // This call doesn't produce matches, so we elide the castleMatchLoop call
-    // entirely and just do escape scans to maintain the repeat.
+    DEBUG_PRINTF("finding final squash in (%lld, %lld]\n", sp, ep);
 
-    size_t eloc = 0;
-    char escaped = castleScan(c, buf, 0, length, &eloc);
-    if (escaped) {
-        assert(eloc < length);
-        DEBUG_PRINTF("escape found at %zu, clearing castle\n", eloc);
-        if (c->exclusive) {
-            partial_store_u32(active - c->activeIdxSize,
-                              c->numRepeats, c->activeIdxSize);
-        }
-
-        if (!c->pureExclusive) {
-            mmbit_clear(active, c->numRepeats);
+    size_t loc;
+
+    if (ep > 0) {
+        if (castleRevScan(c, q->buffer, sp > 0 ? sp : 0, ep, &loc)) {
+            return (s64a)loc;
         }
+        ep = 0;
     }
+
+    if (sp < 0) {
+        s64a hlen = q->hlength;
+
+        if (castleRevScan(c, q->history, sp + hlen, ep + hlen, &loc)) {
+            return (s64a)loc - hlen;
+        }
+        ep = 0;
+    }
+
+    return sp - 1; /* the repeats are never killed */
 }
 
 char nfaExecCastle0_QR(const struct NFA *n, struct mq *q, ReportID report) {
@@ -780,85 +907,44 @@ char nfaExecCastle0_QR(const struct NFA *n, struct mq *q, ReportID report) {
 
     assert(q->cur + 1 < q->end); /* require at least two items */
     assert(q_cur_type(q) == MQE_START);
-    u64a sp = q_cur_offset(q);
-    q->cur++;
-    DEBUG_PRINTF("sp=%llu\n", sp);
 
     const struct Castle *c = getImplNfa(n);
-    u8 *active = (u8 *)q->streamState + c->activeIdxSize;
-    char found = 0;
+    u8 *active = (u8 *)q->streamState + c->activeOffset;
+
+    u64a end_offset = q_last_loc(q) + q->offset;
+    s64a last_kill_loc = castleLastKillLoc(c, q);
+    DEBUG_PRINTF("all repeats killed at %lld (exec range %lld, %lld)\n",
+                 last_kill_loc, q_cur_loc(q), q_last_loc(q));
+    assert(last_kill_loc < q_last_loc(q));
+
+    if (last_kill_loc != q_cur_loc(q) - 1) {
+        clear_repeats(c, q, active);
+    }
+
+    q->cur++; /* skip start event */
+
+    /* skip events prior to the repeats being squashed */
+    while (q_cur_loc(q) <= last_kill_loc) {
+        DEBUG_PRINTF("skipping moot event at %lld\n", q_cur_loc(q));
+        q->cur++;
+        assert(q->cur < q->end);
+    }
+
     while (q->cur < q->end) {
         DEBUG_PRINTF("q item type=%d offset=%llu\n", q_cur_type(q),
                      q_cur_offset(q));
-        found = 0;
-        if (c->exclusive) {
-            const u32 activeIdx = partial_load_u32(q->streamState,
-                                                   c->activeIdxSize);
-            if (activeIdx < c->numRepeats) {
-                found = 1;
-            } else if (c->pureExclusive) {
-                DEBUG_PRINTF("castle is dead\n");
-                goto scan_done;
-            }
-        }
-
-        if (!found && !mmbit_any(active, c->numRepeats)) {
-            DEBUG_PRINTF("castle is dead\n");
-            goto scan_done;
-        }
-
-        u64a ep = q_cur_offset(q);
-
-        if (sp < q->offset) {
-            DEBUG_PRINTF("HISTORY BUFFER SCAN\n");
-            assert(q->offset - sp <= q->hlength);
-            u64a local_ep = MIN(q->offset, ep);
-            const u8 *ptr = q->history + q->hlength + sp - q->offset;
-            castleStreamSilent(c, active, ptr, local_ep - sp);
-            sp = local_ep;
-        }
-
-        found = 0;
-        if (c->exclusive) {
-            const u32 activeIdx = partial_load_u32(q->streamState,
-                                                   c->activeIdxSize);
-            if (activeIdx < c->numRepeats) {
-                found = 1;
-            } else if (c->pureExclusive) {
-                DEBUG_PRINTF("castle is dead\n");
-                goto scan_done;
-            }
-        }
-
-        if (!found && !mmbit_any(active, c->numRepeats)) {
-            DEBUG_PRINTF("castle is dead\n");
-            goto scan_done;
-        }
-
-        if (sp < ep) {
-            DEBUG_PRINTF("MAIN BUFFER SCAN\n");
-            assert(ep - q->offset <= q->length);
-            const u8 *ptr = q->buffer + sp - q->offset;
-            castleStreamSilent(c, active, ptr, ep - sp);
-        }
-
-scan_done:
-        sp = q_cur_offset(q);
-        castleDeactivateStaleSubs(c, sp, q->state, q->streamState);
-        castleHandleEvent(c, q, sp);
+        u64a sp = q_cur_offset(q);
+        castleHandleEvent(c, q, sp, 0);
         q->cur++;
     }
 
-    found = 0;
+    castleDeactivateStaleSubs(c, end_offset, q->state, q->streamState);
+
+    char found = 0;
     if (c->exclusive) {
-        const u32 activeIdx = partial_load_u32(q->streamState,
-                                               c->activeIdxSize);
-        if (activeIdx < c->numRepeats) {
-            found = 1;
-        } else if (c->pureExclusive) {
-            DEBUG_PRINTF("castle is dead\n");
-            return 0;
-        }
+        u8 *groups = (u8 *)q->streamState + c->groupIterOffset;
+        found = mmbit_any_precise(groups, c->numGroups);
+
     }
 
     if (!found && !mmbit_any_precise(active, c->numRepeats)) {
@@ -866,7 +952,7 @@ scan_done:
         return 0;
     }
 
-    if (castleInAccept(c, q, report, sp)) {
+    if (castleInAccept(c, q, report, end_offset)) {
         return MO_MATCHES_PENDING;
     }
 
@@ -901,11 +987,12 @@ char nfaExecCastle0_queueInitState(UNUSED const struct NFA *n, struct mq *q) {
     const struct Castle *c = getImplNfa(n);
     assert(q->streamState);
     if (c->exclusive) {
-        partial_store_u32(q->streamState, c->numRepeats, c->activeIdxSize);
+        u8 *groups = (u8 *)q->streamState + c->groupIterOffset;
+        mmbit_clear(groups, c->numGroups);
     }
 
-    if (!c->pureExclusive) {
-        u8 *active = (u8 *)q->streamState + c->activeIdxSize;
+    if (c->exclusive != PURE_EXCLUSIVE) {
+        u8 *active = (u8 *)q->streamState + c->activeOffset;
         mmbit_clear(active, c->numRepeats);
     }
     return 0;
@@ -919,11 +1006,12 @@ char nfaExecCastle0_initCompressedState(const struct NFA *n, UNUSED u64a offset,
 
     const struct Castle *c = getImplNfa(n);
     if (c->exclusive) {
-        partial_store_u32(state, c->numRepeats, c->activeIdxSize);
+        u8 *groups = (u8 *)state + c->groupIterOffset;
+        mmbit_clear(groups, c->numGroups);
     }
 
-    if (!c->pureExclusive) {
-        u8 *active = (u8 *)state + c->activeIdxSize;
+    if (c->exclusive != PURE_EXCLUSIVE) {
+        u8 *active = (u8 *)state + c->activeOffset;
         mmbit_clear(active, c->numRepeats);
     }
     return 0;
@@ -954,16 +1042,19 @@ char nfaExecCastle0_queueCompressState(const struct NFA *n, const struct mq *q,
     const u64a offset = q->offset + loc;
     DEBUG_PRINTF("offset=%llu\n", offset);
     if (c->exclusive) {
-        const u32 activeIdx = partial_load_u32(q->streamState,
-                                               c->activeIdxSize);
-        if (activeIdx < c->numRepeats) {
+        u8 *active = (u8 *)q->streamState;
+        u8 *groups = active + c->groupIterOffset;
+        for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID);
+             i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) {
+            u8 *cur = active + i * c->activeIdxSize;
+            const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize);
             DEBUG_PRINTF("packing state for sub %u\n", activeIdx);
             subCastleQueueCompressState(c, activeIdx, q, offset);
         }
     }
 
-    if (!c->pureExclusive) {
-        const u8 *active = (const u8 *)q->streamState + c->activeIdxSize;
+    if (c->exclusive != PURE_EXCLUSIVE) {
+        const u8 *active = (const u8 *)q->streamState + c->activeOffset;
         for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID);
              i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) {
             DEBUG_PRINTF("packing state for sub %u\n", i);
@@ -997,15 +1088,19 @@ char nfaExecCastle0_expandState(const struct NFA *n, void *dest,
     const struct Castle *c = getImplNfa(n);
 
     if (c->exclusive) {
-        const u32 activeIdx = partial_load_u32(src, c->activeIdxSize);
-        if (activeIdx < c->numRepeats) {
+        const u8 *active = (const u8 *)src;
+        const u8 *groups = active + c->groupIterOffset;
+        for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID);
+             i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) {
+            const u8 *cur = active + i * c->activeIdxSize;
+            const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize);
             subCastleExpandState(c, activeIdx, dest, src, offset);
         }
     }
 
-    if (!c->pureExclusive) {
+    if (c->exclusive != PURE_EXCLUSIVE) {
         // Unpack state for all active repeats.
-        const u8 *active = (const u8 *)src + c->activeIdxSize;
+        const u8 *active = (const u8 *)src + c->activeOffset;
         for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID);
              i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) {
             subCastleExpandState(c, i, dest, src, offset);
@@ -1013,4 +1108,3 @@ char nfaExecCastle0_expandState(const struct NFA *n, void *dest,
     }
     return 0;
 }
-
diff --git a/src/nfa/castle_dump.cpp b/src/nfa/castle_dump.cpp
index 5f906c2d..dd0e369f 100644
--- a/src/nfa/castle_dump.cpp
+++ b/src/nfa/castle_dump.cpp
@@ -100,6 +100,7 @@ void nfaExecCastle0_dumpText(const struct NFA *nfa, FILE *f) {
         fprintf(f, "unknown type %u\n", c->type);
         break;
     }
+    fprintf(f, "Stale Iter Offset:          %u\n", c->staleIterOffset);
 
     fprintf(f, "\n");
     dumpTextReverse(nfa, f);
diff --git a/src/nfa/castle_internal.h b/src/nfa/castle_internal.h
index 7a061d3d..429c232f 100644
--- a/src/nfa/castle_internal.h
+++ b/src/nfa/castle_internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -42,7 +42,9 @@ struct SubCastle {
     u32 streamStateOffset;  //!< offset within stream state
     u32 repeatInfoOffset;   //!< offset of RepeatInfo structure
                             //   relative to the start of SubCastle
-    char exclusive;         //!< exclusive info of this SubCastle
+    u32 exclusiveId;        //!< exclusive group id of this SubCastle,
+                            //   set to the number of SubCastles in Castle
+                            //   if it is not exclusive
 };
 
 #define CASTLE_DOT 0
@@ -51,6 +53,12 @@ struct SubCastle {
 #define CASTLE_SHUFTI 3
 #define CASTLE_TRUFFLE 4
 
+enum ExclusiveType {
+    NOT_EXCLUSIVE,     //!< no subcastles are exclusive
+    EXCLUSIVE,         //!< a subset of subcastles are exclusive
+    PURE_EXCLUSIVE     //!< all subcastles are exclusive
+};
+
 /**
  * \brief Castle engine structure.
  *
@@ -63,26 +71,60 @@ struct SubCastle {
  * - struct Castle
  * - struct SubCastle[numRepeats]
  * - tables for sparse model repeats
+ * - sparse iterator for subcastles that may be stale
  *
  * Castle stores an "active repeats" multibit in stream state, followed by the
- * packed repeat state for each SubCastle. If all SubCastles are mutual
- * exclusive, we store current active SubCastle id instead of "active repeats"
- * multibit in stream state. If there are both exclusive and non-exclusive
- * SubCastle groups, we use an active id for the exclusive group and a multibit
- * for the non-exclusive group.
+ * packed repeat state for each SubCastle. If there are both exclusive and
+ * non-exclusive SubCastle groups, we use an active id for each exclusive group
+ * and a multibit for the non-exclusive group. We also store an "active
+ * exclusive groups" multibit for exclusive groups. If all SubCastles are mutual
+ * exclusive, we remove "active repeats" multibit from stream state.
+ * * Castle stream state:
+ * *
+ * * |---|
+ * * |   | active subengine id for exclusive group 1
+ * * |---|
+ * * |   | active subengine id for exclusive group 2(if necessary)
+ * * |---|
+ * * ...
+ * * |---|
+ * * |   | "active repeats" multibit for non-exclusive subcastles
+ * * |   | (if not all subcastles are exclusive)
+ * * |---|
+ * * |   | active multibit for exclusive groups
+ * * |   |
+ * * |---|
+ * * ||-|| common pool of stream state for exclusive group 1
+ * * ||-||
+ * * |---|
+ * * ||-|| common pool of stream state for exclusive group 2(if necessary)
+ * * ||-||
+ * * |---|
+ * * ...
+ * * |---|
+ * * |   | stream state for each non-exclusive subcastles
+ * * ...
+ * * |   |
+ * * |---|
  *
  * In full state (stored in scratch space) it stores a temporary multibit over
  * the repeats (used by \ref castleMatchLoop), followed by the repeat control
- * blocks for each SubCastle. If all SubCastles are mutual exclusive, we only
- * need to store the repeat control blocks for each SubCastle.
+ * blocks for each SubCastle.
  */
 struct ALIGN_AVX_DIRECTIVE Castle {
-    u32 numRepeats;
-    u8 type; //!< tells us which scanning mechanism (below) to use
-    char exclusive; //!< tells us if there are mutual exclusive SubCastles
-    char pureExclusive; //!< tells us if all SubCastles are mutual exclusive
-    u8 activeIdxSize; //!< number of bytes in stream state to store
-                      // active SubCastle id for exclusive mode
+    u32 numRepeats;         //!< number of repeats in Castle
+    u32 numGroups;          //!< number of exclusive groups
+    u8 type;                //!< tells us which scanning mechanism (below) to use
+    u8 exclusive;           //!< tells us if there are mutual exclusive SubCastles
+    u8 activeIdxSize;       //!< number of bytes in stream state to store
+                            // active SubCastle id for exclusive mode
+    u32 activeOffset;       //!< offset to active multibit for non-exclusive
+                            // SubCastles
+    u32 staleIterOffset;    //!< offset to a sparse iterator to check for stale
+                            // sub castles
+    u32 groupIterOffset;    //!< offset to a iterator to check the aliveness of
+                            // exclusive groups
+
     union {
         struct {
             char c;
diff --git a/src/nfa/castlecompile.cpp b/src/nfa/castlecompile.cpp
index e5cc9267..4bddf767 100644
--- a/src/nfa/castlecompile.cpp
+++ b/src/nfa/castlecompile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -32,6 +32,7 @@
 #include "castlecompile.h"
 
 #include "castle_internal.h"
+#include "limex_limits.h"
 #include "nfa_internal.h"
 #include "repeatcompile.h"
 #include "shufticompile.h"
@@ -47,7 +48,9 @@
 #include "util/dump_charclass.h"
 #include "util/graph.h"
 #include "util/make_unique.h"
+#include "util/multibit_build.h"
 #include "util/multibit_internal.h"
+#include "util/report_manager.h"
 #include "util/ue2_containers.h"
 #include "util/verify_types.h"
 #include "grey.h"
@@ -63,7 +66,6 @@ using boost::adaptors::map_values;
 
 namespace ue2 {
 
-#define CASTLE_MAX_TOPS 32
 #define CLIQUE_GRAPH_MAX_SIZE 1000
 
 static
@@ -204,7 +206,7 @@ bool graph_empty(const Graph &g) {
 static
 vector<u32> removeClique(CliqueGraph &cg) {
     vector<vector<u32>> cliquesVec(1);
-    DEBUG_PRINTF("graph size:%lu\n", num_vertices(cg));
+    DEBUG_PRINTF("graph size:%zu\n", num_vertices(cg));
     findCliqueGroup(cg, cliquesVec[0]);
     while (!graph_empty(cg)) {
         const vector<u32> &c = cliquesVec.back();
@@ -236,7 +238,7 @@ vector<u32> removeClique(CliqueGraph &cg) {
         }
     }
 
-    DEBUG_PRINTF("clique size:%lu\n", cliquesVec[id].size());
+    DEBUG_PRINTF("clique size:%zu\n", cliquesVec[id].size());
     return cliquesVec[id];
 }
 
@@ -244,17 +246,18 @@ vector<u32> removeClique(CliqueGraph &cg) {
 // the end locations where it overlaps with other literals,
 // then the literals are mutual exclusive
 static
-bool findExclusivePair(const u32 id1, const u32 id2,
+bool findExclusivePair(const size_t id1, const size_t id2,
+                       const size_t lower,
                        const vector<vector<size_t>> &min_reset_dist,
                        const vector<vector<vector<CharReach>>> &triggers) {
     const auto &triggers1 = triggers[id1];
     const auto &triggers2 = triggers[id2];
-    for (u32 i = 0; i < triggers1.size(); ++i) {
-        for (u32 j = 0; j < triggers2.size(); ++j) {
+    for (size_t i = 0; i < triggers1.size(); ++i) {
+        for (size_t j = 0; j < triggers2.size(); ++j) {
             if (!literalOverlap(triggers1[i], triggers2[j],
-                                min_reset_dist[id2][j]) ||
+                                min_reset_dist[id2 - lower][j]) ||
                 !literalOverlap(triggers2[j], triggers1[i],
-                                min_reset_dist[id1][i])) {
+                                min_reset_dist[id1 - lower][i])) {
                 return false;
             }
         }
@@ -263,40 +266,75 @@ bool findExclusivePair(const u32 id1, const u32 id2,
 }
 
 static
-vector<u32> checkExclusion(const CharReach &cr,
-                           const vector<vector<vector<CharReach>>> &triggers) {
-    vector<u32> group;
-    if (!triggers.size() || triggers.size() == 1) {
-        return group;
-    }
+vector<vector<u32>> checkExclusion(u32 &streamStateSize,
+                       const CharReach &cr,
+                       const vector<vector<vector<CharReach>>> &triggers,
+                       enum ExclusiveType &exclusive,
+                       const size_t numRepeats) {
+    vector<vector<u32>> groups;
+    size_t trigSize = triggers.size();
+    DEBUG_PRINTF("trigSize %zu\n", trigSize);
 
-    vector<vector<size_t>> min_reset_dist;
-    // get min reset distance for each repeat
-    for (auto it = triggers.begin(); it != triggers.end(); it++) {
-        const vector<size_t> &tmp_dist = minResetDistToEnd(*it, cr);
-        min_reset_dist.push_back(tmp_dist);
-    }
+    size_t lower = 0;
+    size_t total = 0;
+    while (lower < trigSize) {
+        vector<CliqueVertex> vertices;
+        unique_ptr<CliqueGraph> cg = make_unique<CliqueGraph>();
 
-    vector<CliqueVertex> vertices;
-    unique_ptr<CliqueGraph> cg = make_unique<CliqueGraph>();
-    for (u32 i = 0; i < triggers.size(); ++i) {
-        CliqueVertex v = add_vertex(CliqueVertexProps(i), *cg);
-        vertices.push_back(v);
-    }
+        vector<vector<size_t>> min_reset_dist;
+        size_t upper = min(lower + CLIQUE_GRAPH_MAX_SIZE, trigSize);
+        // get min reset distance for each repeat
+        for (size_t i = lower; i < upper; i++) {
+            CliqueVertex v = add_vertex(CliqueVertexProps(i), *cg);
+            vertices.push_back(v);
 
-    // find exclusive pair for each repeat
-    for (u32 i = 0; i < triggers.size(); ++i) {
-        CliqueVertex s = vertices[i];
-        for (u32 j = i + 1; j < triggers.size(); ++j) {
-            if (findExclusivePair(i, j, min_reset_dist, triggers)) {
-                CliqueVertex d = vertices[j];
-                add_edge(s, d, *cg);
+            const vector<size_t> &tmp_dist =
+                minResetDistToEnd(triggers[i], cr);
+            min_reset_dist.push_back(tmp_dist);
+        }
+
+        // find exclusive pair for each repeat
+        for (size_t i = lower; i < upper; i++) {
+            CliqueVertex s = vertices[i - lower];
+            for (size_t j = i + 1; j < upper; j++) {
+                if (findExclusivePair(i, j, lower, min_reset_dist,
+                                      triggers)) {
+                    CliqueVertex d = vertices[j - lower];
+                    add_edge(s, d, *cg);
+                }
             }
         }
-    }
 
-    // find the largest exclusive group
-    return removeClique(*cg);
+        // find the largest exclusive group
+        auto clique = removeClique(*cg);
+        size_t cliqueSize = clique.size();
+        if (cliqueSize > 1) {
+            groups.push_back(clique);
+            exclusive = EXCLUSIVE;
+            total += cliqueSize;
+        }
+
+        lower += CLIQUE_GRAPH_MAX_SIZE;
+    }
+    DEBUG_PRINTF("clique size %zu, num of repeats %zu\n",
+                 total, numRepeats);
+    if (total == numRepeats) {
+        exclusive = PURE_EXCLUSIVE;
+        streamStateSize = 0;
+    };
+
+    return groups;
+}
+
+namespace {
+struct ExclusiveInfo {
+
+    /** Mapping between top and exclusive group id */
+    map<u32, u32> groupId;
+
+    /** Number of exclusive groups */
+    u32 numGroups = 0;
+};
 }
 
 static
@@ -305,10 +343,15 @@ void buildSubcastles(const CastleProto &proto, vector<SubCastle> &subs,
                      const vector<pair<depth, bool>> &repeatInfoPair,
                      u32 &scratchStateSize, u32 &streamStateSize,
                      u32 &tableSize, vector<u64a> &tables, u32 &sparseRepeats,
-                     const set<u32> &exclusiveGroup) {
+                     const ExclusiveInfo &exclusiveInfo,
+                     vector<u32> &may_stale, const ReportManager &rm) {
+    const bool remap_reports = has_managed_reports(proto.kind);
+
     u32 i = 0;
-    u32 maxStreamSize = 0;
-    bool exclusive = exclusiveGroup.size() > 1;
+    const auto &groupId = exclusiveInfo.groupId;
+    const auto &numGroups = exclusiveInfo.numGroups;
+    vector<u32> maxStreamSize(numGroups, 0);
+
     for (auto it = proto.repeats.begin(), ite = proto.repeats.end();
          it != ite; ++it, ++i) {
         const PureRepeat &pr = it->second;
@@ -316,33 +359,35 @@ void buildSubcastles(const CastleProto &proto, vector<SubCastle> &subs,
         bool is_reset = repeatInfoPair[i].second;
 
         enum RepeatType rtype = chooseRepeatType(pr.bounds.min, pr.bounds.max,
-                                                 min_period, is_reset);
+                                                 min_period, is_reset, true);
         RepeatStateInfo rsi(rtype, pr.bounds.min, pr.bounds.max, min_period);
 
         DEBUG_PRINTF("sub %u: selected %s model for %s repeat\n", i,
                      repeatTypeName(rtype), pr.bounds.str().c_str());
 
-        u32 subScratchStateSize;
-        u32 subStreamStateSize;
-
         SubCastle &sub = subs[i];
         RepeatInfo &info = infos[i];
 
-        // handle exclusive case differently
-        if (exclusive && exclusiveGroup.find(i) != exclusiveGroup.end()) {
-            maxStreamSize = MAX(maxStreamSize, rsi.packedCtrlSize);
-        } else {
-            subScratchStateSize = verify_u32(sizeof(RepeatControl));
-            subStreamStateSize = verify_u32(rsi.packedCtrlSize + rsi.stateSize);
+        info.packedCtrlSize = rsi.packedCtrlSize;
+        u32 subStreamStateSize = verify_u32(rsi.packedCtrlSize + rsi.stateSize);
 
-            info.packedCtrlSize = rsi.packedCtrlSize;
+        // Handle stream/scratch space alloc for exclusive case differently.
+        if (contains(groupId, i)) {
+            u32 id = groupId.at(i);
+            maxStreamSize[id] = max(maxStreamSize[id], subStreamStateSize);
+            // SubCastle full/stream state offsets are written in for the group
+            // below.
+        } else {
             sub.fullStateOffset = scratchStateSize;
             sub.streamStateOffset = streamStateSize;
-
-            scratchStateSize += subScratchStateSize;
+            scratchStateSize += verify_u32(sizeof(RepeatControl));
             streamStateSize += subStreamStateSize;
         }
 
+        if (pr.bounds.max.is_finite()) {
+            may_stale.push_back(i);
+        }
+
         info.type = verify_u8(rtype);
         info.repeatMin = depth_to_u32(pr.bounds.min);
         info.repeatMax = depth_to_u32(pr.bounds.max);
@@ -358,35 +403,44 @@ void buildSubcastles(const CastleProto &proto, vector<SubCastle> &subs,
         info.encodingSize = rsi.encodingSize;
         info.patchesOffset = rsi.patchesOffset;
 
-        sub.report = *pr.reports.begin();
+        assert(pr.reports.size() == 1);
+        ReportID id = *pr.reports.begin();
+        sub.report = remap_reports ? rm.getProgramOffset(id) : id;
 
         if (rtype == REPEAT_SPARSE_OPTIMAL_P) {
-           for (u32 j = 0; j < rsi.patchSize; j++) {
-               tables.push_back(rsi.table[j]);
-           }
-           sparseRepeats++;
-           patchSize[i] = rsi.patchSize;
-           tableSize += rsi.patchSize;
+            for (u32 j = 0; j < rsi.patchSize; j++) {
+                tables.push_back(rsi.table[j]);
+            }
+            sparseRepeats++;
+            patchSize[i] = rsi.patchSize;
+            tableSize += rsi.patchSize;
         }
     }
 
-    if (exclusive) {
-        for (auto k : exclusiveGroup) {
-            SubCastle &sub = subs[k];
-            RepeatInfo &info = infos[k];
-            info.packedCtrlSize = maxStreamSize;
+    vector<u32> scratchOffset(numGroups, 0);
+    vector<u32> streamOffset(numGroups, 0);
+    for (const auto &j : groupId) {
+        u32 top = j.first;
+        u32 id = j.second;
+        SubCastle &sub = subs[top];
+        if (!scratchOffset[id]) {
             sub.fullStateOffset = scratchStateSize;
             sub.streamStateOffset = streamStateSize;
+            scratchOffset[id] = scratchStateSize;
+            streamOffset[id] = streamStateSize;
+            scratchStateSize += verify_u32(sizeof(RepeatControl));
+            streamStateSize += maxStreamSize[id];
+        } else {
+            sub.fullStateOffset = scratchOffset[id];
+            sub.streamStateOffset = streamOffset[id];
         }
-        scratchStateSize += verify_u32(sizeof(RepeatControl));
-        streamStateSize += maxStreamSize;
     }
 }
 
 aligned_unique_ptr<NFA>
 buildCastle(const CastleProto &proto,
             const map<u32, vector<vector<CharReach>>> &triggers,
-            const CompileContext &cc) {
+            const CompileContext &cc, const ReportManager &rm) {
     assert(cc.grey.allowCastle);
 
     const size_t numRepeats = proto.repeats.size();
@@ -418,8 +472,9 @@ buildCastle(const CastleProto &proto,
     depth maxWidth(0);
 
     u32 i = 0;
-    vector<u32> candidateRepeats;
+    ExclusiveInfo exclusiveInfo;
     vector<vector<vector<CharReach>>> candidateTriggers;
+    vector<u32> candidateRepeats;
     vector<pair<depth, bool>> repeatInfoPair;
     for (auto it = proto.repeats.begin(), ite = proto.repeats.end();
          it != ite; ++it, ++i) {
@@ -454,49 +509,60 @@ buildCastle(const CastleProto &proto,
 
         repeatInfoPair.push_back(make_pair(min_period, is_reset));
 
-        if (is_reset && candidateRepeats.size() < CLIQUE_GRAPH_MAX_SIZE) {
-            candidateTriggers.push_back(triggers.at(top));
-            candidateRepeats.push_back(i);
-        }
+        candidateTriggers.push_back(triggers.at(top));
+        candidateRepeats.push_back(i);
     }
 
     // Case 1: exclusive repeats
-    bool exclusive = false;
-    bool pureExclusive = false;
+    enum ExclusiveType exclusive = NOT_EXCLUSIVE;
     u32 activeIdxSize = 0;
-    set<u32> exclusiveGroup;
+    u32 groupIterOffset = 0;
     if (cc.grey.castleExclusive) {
-        vector<u32> tmpGroup = checkExclusion(cr, candidateTriggers);
-        const u32 exclusiveSize = tmpGroup.size();
-        if (exclusiveSize > 1) {
-            // Case 1: mutual exclusive repeats group found, initialize state
-            // sizes
-            exclusive = true;
+        auto cliqueGroups =
+            checkExclusion(streamStateSize, cr, candidateTriggers,
+                           exclusive, numRepeats);
+        for (const auto &group : cliqueGroups) {
+            // mutual exclusive repeats group found,
+            // update state sizes
             activeIdxSize = calcPackedBytes(numRepeats + 1);
-            if (exclusiveSize == numRepeats) {
-                pureExclusive = true;
-                streamStateSize = 0;
-                scratchStateSize = 0;
-            }
             streamStateSize += activeIdxSize;
 
             // replace with top values
-            for (const auto &val : tmpGroup) {
-                exclusiveGroup.insert(candidateRepeats[val]);
+            for (const auto &val : group) {
+                const u32 top = candidateRepeats[val];
+                exclusiveInfo.groupId[top] = exclusiveInfo.numGroups;
             }
+            exclusiveInfo.numGroups++;
         }
+
+        if (exclusive) {
+            groupIterOffset = streamStateSize;
+            streamStateSize += mmbit_size(exclusiveInfo.numGroups);
+        }
+
+        DEBUG_PRINTF("num of groups:%u\n", exclusiveInfo.numGroups);
     }
+    candidateRepeats.clear();
 
     DEBUG_PRINTF("reach %s exclusive %u\n", describeClass(cr).c_str(),
                  exclusive);
 
     u32 tableSize = 0;
     u32 sparseRepeats = 0;
+    vector<u32> may_stale; /* sub castles that may go stale */
+
     buildSubcastles(proto, subs, infos, patchSize, repeatInfoPair,
                     scratchStateSize, streamStateSize, tableSize,
-                    tables, sparseRepeats, exclusiveGroup);
+                    tables, sparseRepeats, exclusiveInfo, may_stale, rm);
 
-    const size_t total_size =
+    DEBUG_PRINTF("%zu subcastles may go stale\n", may_stale.size());
+    vector<mmbit_sparse_iter> stale_iter;
+    if (!may_stale.empty()) {
+        mmbBuildSparseIterator(stale_iter, may_stale, numRepeats);
+    }
+
+
+    size_t total_size =
         sizeof(NFA) +                      // initial NFA structure
         sizeof(Castle) +                   // Castle structure
         sizeof(SubCastle) * subs.size() +  // SubCastles themselves
@@ -506,6 +572,9 @@ buildCastle(const CastleProto &proto,
         sizeof(u64a) * sparseRepeats;      // paddings for
                                            // REPEAT_SPARSE_OPTIMAL_P tables
 
+    total_size = ROUNDUP_N(total_size, alignof(mmbit_sparse_iter));
+    total_size += byte_length(stale_iter); // stale sparse iter
+
     aligned_unique_ptr<NFA> nfa = aligned_zmalloc_unique<NFA>(total_size);
     nfa->type = verify_u8(CASTLE_NFA_0);
     nfa->length = verify_u32(total_size);
@@ -515,12 +584,15 @@ buildCastle(const CastleProto &proto,
     nfa->minWidth = verify_u32(minWidth);
     nfa->maxWidth = maxWidth.is_finite() ? verify_u32(maxWidth) : 0;
 
-    char *ptr = (char *)nfa.get() + sizeof(NFA);
+    char * const base_ptr = (char *)nfa.get() + sizeof(NFA);
+    char *ptr = base_ptr;
     Castle *c = (Castle *)ptr;
     c->numRepeats = verify_u32(subs.size());
-    c->exclusive = exclusive;
-    c->pureExclusive = pureExclusive;
+    c->numGroups = exclusiveInfo.numGroups;
+    c->exclusive = verify_s8(exclusive);
     c->activeIdxSize = verify_u8(activeIdxSize);
+    c->activeOffset = verify_u32(c->numGroups * activeIdxSize);
+    c->groupIterOffset = groupIterOffset;
 
     writeCastleScanEngine(cr, c);
 
@@ -554,12 +626,22 @@ buildCastle(const CastleProto &proto,
         }
 
         // set exclusive group info
-        if (exclusiveGroup.find(i) != exclusiveGroup.end()) {
-            sub->exclusive = 1;
+        if (contains(exclusiveInfo.groupId, i)) {
+            sub->exclusiveId = exclusiveInfo.groupId[i];
         } else {
-            sub->exclusive = 0;
+            sub->exclusiveId = numRepeats;
         }
     }
+
+    ptr = base_ptr + total_size - sizeof(NFA) - byte_length(stale_iter);
+
+    assert(ptr + byte_length(stale_iter) == base_ptr + total_size - sizeof(NFA));
+    if (!stale_iter.empty()) {
+        c->staleIterOffset = verify_u32(ptr - base_ptr);
+        copy_bytes(ptr, stale_iter);
+        ptr += byte_length(stale_iter);
+    }
+
     return nfa;
 }
 
@@ -603,7 +685,7 @@ depth findMaxWidth(const CastleProto &proto, u32 top) {
     return proto.repeats.at(top).bounds.max;
 }
 
-CastleProto::CastleProto(const PureRepeat &pr) {
+CastleProto::CastleProto(nfa_kind k, const PureRepeat &pr) : kind(k) {
     assert(pr.reach.any());
     assert(pr.reports.size() == 1);
     u32 top = 0;
@@ -665,6 +747,7 @@ u32 CastleProto::merge(const PureRepeat &pr) {
 bool mergeCastle(CastleProto &c1, const CastleProto &c2,
                  map<u32, u32> &top_map) {
     assert(&c1 != &c2);
+    assert(c1.kind == c2.kind);
 
     DEBUG_PRINTF("c1 has %zu repeats, c2 has %zu repeats\n", c1.repeats.size(),
                  c2.repeats.size());
@@ -738,6 +821,7 @@ bool is_equal(const CastleProto &c1, ReportID report1, const CastleProto &c2,
               ReportID report2) {
     assert(!c1.repeats.empty());
     assert(!c2.repeats.empty());
+    assert(c1.kind == c2.kind);
 
     if (c1.reach() != c2.reach()) {
         DEBUG_PRINTF("different reach\n");
@@ -784,6 +868,7 @@ bool is_equal(const CastleProto &c1, ReportID report1, const CastleProto &c2,
 bool is_equal(const CastleProto &c1, const CastleProto &c2) {
     assert(!c1.repeats.empty());
     assert(!c2.repeats.empty());
+    assert(c1.kind == c2.kind);
 
     if (c1.reach() != c2.reach()) {
         DEBUG_PRINTF("different reach\n");
@@ -877,7 +962,7 @@ bool hasZeroMinBound(const CastleProto &proto) {
     return false;
 }
 
-unique_ptr<NGHolder> makeHolder(const CastleProto &proto, nfa_kind kind,
+unique_ptr<NGHolder> makeHolder(const CastleProto &proto,
                                 const CompileContext &cc) {
     assert(!proto.repeats.empty());
 
@@ -890,10 +975,10 @@ unique_ptr<NGHolder> makeHolder(const CastleProto &proto, nfa_kind kind,
         }
     }
 
-    unique_ptr<NGHolder> g = ue2::make_unique<NGHolder>(kind);
+    auto g = ue2::make_unique<NGHolder>(proto.kind);
 
     for (const auto &m : proto.repeats) {
-        if (m.first >= CASTLE_MAX_TOPS) {
+        if (m.first >= NFA_MAX_TOP_MASKS) {
             DEBUG_PRINTF("top %u too big for an NFA\n", m.first);
             return nullptr;
         }
diff --git a/src/nfa/castlecompile.h b/src/nfa/castlecompile.h
index fc4bb991..938e57c4 100644
--- a/src/nfa/castlecompile.h
+++ b/src/nfa/castlecompile.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -51,6 +51,7 @@ namespace ue2 {
 
 class CharReach;
 class NGHolder;
+class ReportManager;
 struct CompileContext;
 
 /**
@@ -65,7 +66,7 @@ struct CompileContext;
  */
 struct CastleProto {
     static constexpr size_t max_occupancy = 65536; // arbitrary limit
-    explicit CastleProto(const PureRepeat &pr);
+    CastleProto(nfa_kind k, const PureRepeat &pr);
     const CharReach &reach() const;
 
     /** \brief Add a new repeat. */
@@ -94,6 +95,9 @@ struct CastleProto {
      * so we track this explicitly instead of using repeats.size().
      */
     u32 next_top = 1;
+
+    /** \brief Kind for this engine. */
+    nfa_kind kind;
 };
 
 std::set<ReportID> all_reports(const CastleProto &proto);
@@ -119,7 +123,7 @@ void remapCastleTops(CastleProto &proto, std::map<u32, u32> &top_map);
 ue2::aligned_unique_ptr<NFA>
 buildCastle(const CastleProto &proto,
             const std::map<u32, std::vector<std::vector<CharReach>>> &triggers,
-            const CompileContext &cc);
+            const CompileContext &cc, const ReportManager &rm);
 
 /**
  * \brief Merge two CastleProto prototypes together, if possible.
@@ -155,7 +159,7 @@ bool requiresDedupe(const CastleProto &proto,
 /**
  * \brief Build an NGHolder from a CastleProto.
  */
-std::unique_ptr<NGHolder> makeHolder(const CastleProto &castle, nfa_kind kind,
+std::unique_ptr<NGHolder> makeHolder(const CastleProto &castle,
                                      const CompileContext &cc);
 
 } // namespace ue2
diff --git a/src/nfa/gough.c b/src/nfa/gough.c
index 42a252e5..c52bca06 100644
--- a/src/nfa/gough.c
+++ b/src/nfa/gough.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -1049,15 +1049,16 @@ char nfaExecGough16_inAccept(const struct NFA *n, ReportID report,
 }
 
 static
-void goughCheckEOD(const struct NFA *nfa, u16 s,
+char goughCheckEOD(const struct NFA *nfa, u16 s,
                    const struct gough_som_info *som,
                    u64a offset, SomNfaCallback cb, void *ctxt) {
     const struct mcclellan *m = (const struct mcclellan *)getImplNfa(nfa);
     const struct mstate_aux *aux = get_aux(m, s);
 
-    if (aux->accept_eod) {
-        doReports(cb, ctxt, m, som, s, offset, 1, NULL, NULL, NULL);
+    if (!aux->accept_eod) {
+        return MO_CONTINUE_MATCHING;
     }
+    return doReports(cb, ctxt, m, som, s, offset, 1, NULL, NULL, NULL);
 }
 
 char nfaExecGough8_testEOD(const struct NFA *nfa, const char *state,
@@ -1065,8 +1066,8 @@ char nfaExecGough8_testEOD(const struct NFA *nfa, const char *state,
                           UNUSED NfaCallback callback,
                           SomNfaCallback som_callback, void *context) {
     const struct gough_som_info *som = getSomInfoConst(state);
-    goughCheckEOD(nfa, *(const u8 *)state, som, offset, som_callback, context);
-    return 0;
+    return goughCheckEOD(nfa, *(const u8 *)state, som, offset, som_callback,
+                         context);
 }
 
 char nfaExecGough16_testEOD(const struct NFA *nfa, const char *state,
@@ -1075,8 +1076,8 @@ char nfaExecGough16_testEOD(const struct NFA *nfa, const char *state,
                            SomNfaCallback som_callback, void *context) {
     assert(ISALIGNED_N(state, 8));
     const struct gough_som_info *som = getSomInfoConst(state);
-    goughCheckEOD(nfa, *(const u16 *)state, som, offset, som_callback, context);
-    return 0;
+    return goughCheckEOD(nfa, *(const u16 *)state, som, offset, som_callback,
+                         context);
 }
 
 char nfaExecGough8_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) {
diff --git a/src/nfa/goughcompile.cpp b/src/nfa/goughcompile.cpp
index d735c80a..647dc496 100644
--- a/src/nfa/goughcompile.cpp
+++ b/src/nfa/goughcompile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -41,8 +41,9 @@
 #include "util/graph_range.h"
 #include "util/make_unique.h"
 #include "util/order_check.h"
-#include "util/verify_types.h"
+#include "util/report_manager.h"
 #include "util/ue2_containers.h"
+#include "util/verify_types.h"
 
 #include "ue2common.h"
 
@@ -77,18 +78,20 @@ namespace {
 
 class gough_build_strat : public mcclellan_build_strat {
 public:
-    gough_build_strat(raw_som_dfa &r, const GoughGraph &g,
-            const map<dstate_id_t, gough_accel_state_info> &accel_info)
-        : mcclellan_build_strat(r), rdfa(r), gg(g),
+    gough_build_strat(
+        raw_som_dfa &r, const GoughGraph &g, const ReportManager &rm,
+        const map<dstate_id_t, gough_accel_state_info> &accel_info)
+        : mcclellan_build_strat(r, rm), rdfa(r), gg(g),
           accel_gough_info(accel_info) {}
     unique_ptr<raw_report_info> gatherReports(vector<u32> &reports /* out */,
                             vector<u32> &reports_eod /* out */,
                             u8 *isSingleReport /* out */,
                             ReportID *arbReport  /* out */) const override;
-    void find_escape_strings(dstate_id_t this_idx,
-                             escape_info *out) const override;
+    AccelScheme find_escape_strings(dstate_id_t this_idx) const override;
     size_t accelSize(void) const override { return sizeof(gough_accel); }
-    void buildAccel(dstate_id_t this_idx, void *accel_out) override;
+    void buildAccel(dstate_id_t this_idx, const AccelScheme &info,
+                    void *accel_out) override;
+    u32 max_allowed_offset_accel() const override { return 0; }
 
     raw_som_dfa &rdfa;
     const GoughGraph &gg;
@@ -1034,7 +1037,8 @@ void update_accel_prog_offset(const gough_build_strat &gbs,
 }
 
 aligned_unique_ptr<NFA> goughCompile(raw_som_dfa &raw, u8 somPrecision,
-                                     const CompileContext &cc) {
+                                     const CompileContext &cc,
+                                     const ReportManager &rm) {
     assert(somPrecision == 2 || somPrecision == 4 || somPrecision == 8
            || !cc.streaming);
 
@@ -1066,7 +1070,7 @@ aligned_unique_ptr<NFA> goughCompile(raw_som_dfa &raw, u8 somPrecision,
 
     map<dstate_id_t, gough_accel_state_info> accel_allowed;
     find_allowed_accel_states(*cfg, blocks, &accel_allowed);
-    gough_build_strat gbs(raw, *cfg, accel_allowed);
+    gough_build_strat gbs(raw, *cfg, rm, accel_allowed);
     aligned_unique_ptr<NFA> basic_dfa = mcclellanCompile_i(raw, gbs, cc);
     assert(basic_dfa);
     if (!basic_dfa) {
@@ -1145,32 +1149,44 @@ aligned_unique_ptr<NFA> goughCompile(raw_som_dfa &raw, u8 somPrecision,
     return gough_dfa;
 }
 
-void gough_build_strat::find_escape_strings(dstate_id_t this_idx,
-                                            escape_info *out) const {
+AccelScheme gough_build_strat::find_escape_strings(dstate_id_t this_idx) const {
+    AccelScheme rv;
     if (!contains(accel_gough_info, this_idx)) {
-        out->outs = CharReach::dot();
-        out->outs2_broken = true;
-        return;
+        rv.cr = CharReach::dot();
+        rv.double_byte.clear();
+        return rv;
     }
 
-    mcclellan_build_strat::find_escape_strings(this_idx, out);
+    rv = mcclellan_build_strat::find_escape_strings(this_idx);
 
-    if (!accel_gough_info.at(this_idx).two_byte) {
-        out->outs2_broken = true;
+    assert(!rv.offset || rv.cr.all()); /* should have been limited by strat */
+    if (rv.offset) {
+        rv.cr = CharReach::dot();
+        rv.double_byte.clear();
+        return rv;
     }
+
+    if (rv.double_offset
+        || !accel_gough_info.at(this_idx).two_byte) {
+        rv.double_byte.clear();
+    }
+
+    return rv;
 }
 
-void gough_build_strat::buildAccel(dstate_id_t this_idx, void *accel_out) {
+void gough_build_strat::buildAccel(dstate_id_t this_idx, const AccelScheme &info,
+                                   void *accel_out) {
     assert(mcclellan_build_strat::accelSize() == sizeof(AccelAux));
     gough_accel *accel = (gough_accel *)accel_out;
     /* build a plain accelaux so we can work out where we can get to */
-    mcclellan_build_strat::buildAccel(this_idx, &accel->accel);
+    mcclellan_build_strat::buildAccel(this_idx, info, &accel->accel);
     DEBUG_PRINTF("state %hu is accel with type %hhu\n", this_idx,
                  accel->accel.accel_type);
     if (accel->accel.accel_type == ACCEL_NONE) {
         return;
     }
 
+    assert(!accel->accel.generic.offset);
     assert(contains(accel_gough_info, this_idx));
     accel->margin_dist = verify_u8(accel_gough_info.at(this_idx).margin);
     built_accel[accel] = this_idx;
@@ -1182,10 +1198,11 @@ namespace {
 struct raw_gough_report_list {
     set<som_report> reports;
 
-    explicit raw_gough_report_list(
-        const vector<pair<ReportID, GoughSSAVar *>> &raw_reports) {
+    raw_gough_report_list(
+        const vector<pair<ReportID, GoughSSAVar *>> &raw_reports,
+        const ReportManager &rm, bool do_remap) {
         for (const auto &m : raw_reports) {
-            ReportID r = m.first;
+            ReportID r = do_remap ? rm.getProgramOffset(m.first) : m.first;
             u32 impl_slot = INVALID_SLOT;
             if (m.second) {
                 impl_slot = m.second->slot;
@@ -1214,11 +1231,13 @@ unique_ptr<raw_report_info> gough_build_strat::gatherReports(
                                                   vector<u32> &reports_eod,
                                                   u8 *isSingleReport,
                                                   ReportID *arbReport) const {
-    unique_ptr<raw_gough_report_info_impl> ri =
-        ue2::make_unique<raw_gough_report_info_impl>();
-    map<raw_gough_report_list, u32> rev;
     DEBUG_PRINTF("gathering reports\n");
 
+    const bool remap_reports = has_managed_reports(rdfa.kind);
+
+    auto ri = ue2::make_unique<raw_gough_report_info_impl>();
+    map<raw_gough_report_list, u32> rev;
+
     assert(!rdfa.states.empty());
 
     vector<GoughVertex> verts(rdfa.states.size());
@@ -1237,7 +1256,7 @@ unique_ptr<raw_report_info> gough_build_strat::gatherReports(
             continue;
         }
 
-        raw_gough_report_list rrl(gg[v].reports);
+        raw_gough_report_list rrl(gg[v].reports, rm, remap_reports);
         DEBUG_PRINTF("non empty r %zu\n", reports.size());
         if (rev.find(rrl) != rev.end()) {
             reports.push_back(rev[rrl]);
@@ -1256,7 +1275,7 @@ unique_ptr<raw_report_info> gough_build_strat::gatherReports(
         }
 
         DEBUG_PRINTF("non empty r eod\n");
-        raw_gough_report_list rrl(gg[v].reports_eod);
+        raw_gough_report_list rrl(gg[v].reports_eod, rm, remap_reports);
         if (rev.find(rrl) != rev.end()) {
             reports_eod.push_back(rev[rrl]);
             continue;
diff --git a/src/nfa/goughcompile.h b/src/nfa/goughcompile.h
index 9da983d4..54f98cef 100644
--- a/src/nfa/goughcompile.h
+++ b/src/nfa/goughcompile.h
@@ -89,7 +89,8 @@ struct raw_som_dfa : public raw_dfa {
 };
 
 aligned_unique_ptr<NFA> goughCompile(raw_som_dfa &raw, u8 somPrecision,
-                                     const CompileContext &cc);
+                                     const CompileContext &cc,
+                                     const ReportManager &rm);
 
 } // namespace ue2
 
diff --git a/src/nfa/lbr.c b/src/nfa/lbr.c
index de93d4a3..0d69cc2a 100644
--- a/src/nfa/lbr.c
+++ b/src/nfa/lbr.c
@@ -130,6 +130,9 @@ char repeatIsDead(const struct RepeatInfo *info,
         return lstate->ctrl.ring.offset == REPEAT_DEAD;
     case REPEAT_TRAILER:
         return lstate->ctrl.trailer.offset == REPEAT_DEAD;
+    case REPEAT_ALWAYS:
+        assert(!"REPEAT_ALWAYS should only be used by Castle");
+        return 0;
     }
 
     assert(0);
diff --git a/src/nfa/limex.h b/src/nfa/limex.h
index 3f1e49a3..2c429a67 100644
--- a/src/nfa/limex.h
+++ b/src/nfa/limex.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -65,14 +65,13 @@ extern "C"
                                        void *state, u8 key);                   \
     char gf_name##_B_Reverse(const struct NFA *n, u64a offset, const u8 *buf,  \
                              size_t buflen, const u8 *hbuf, size_t hlen,       \
-                             struct hs_scratch *scratch, NfaCallback cb,       \
-                             void *context);                                   \
+                             NfaCallback cb, void *context);                   \
     char gf_name##_queueCompressState(const struct NFA *nfa,                   \
                                       const struct mq *q, s64a loc);           \
     char gf_name##_expandState(const struct NFA *nfa, void *dest,              \
                                const void *src, u64a offset, u8 key);          \
-    enum nfa_zombie_status gf_name##_zombie_status(const struct NFA *nfa,    \
-                                                   struct mq *q, s64a loc); \
+    enum nfa_zombie_status gf_name##_zombie_status(const struct NFA *nfa,      \
+                                                   struct mq *q, s64a loc);    \
     GENERATE_NFA_DUMP_DECL(gf_name)
 
 GENERATE_NFA_DECL(nfaExecLimEx32_1)
diff --git a/src/nfa/limex_accel.c b/src/nfa/limex_accel.c
index 1aa1b30f..2c73f9ff 100644
--- a/src/nfa/limex_accel.c
+++ b/src/nfa/limex_accel.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -38,6 +38,9 @@
 #include "nfa_internal.h"
 #include "shufti.h"
 #include "truffle.h"
+#include "multishufti.h"
+#include "multitruffle.h"
+#include "multivermicelli.h"
 #include "ue2common.h"
 #include "vermicelli.h"
 #include "util/bitutils.h"
@@ -46,74 +49,6 @@
 #include "util/simd_utils_ssse3.h"
 #include "util/shuffle_ssse3.h"
 
-static
-const u8 *accelScan(const union AccelAux *aux, const u8 *ptr, const u8 *end) {
-    assert(ISALIGNED(aux)); // must be SIMD aligned for shufti
-    assert(end > ptr);
-    assert(end - ptr >= 16); // must be at least 16 bytes to scan
-
-    const u8 *start = ptr;
-    u8 offset;
-    switch (aux->accel_type) {
-    case ACCEL_VERM:
-        DEBUG_PRINTF("single vermicelli for 0x%02hhx\n", aux->verm.c);
-        offset = aux->verm.offset;
-        ptr = vermicelliExec(aux->verm.c, 0, ptr, end);
-        break;
-    case ACCEL_VERM_NOCASE:
-        DEBUG_PRINTF("single vermicelli-nocase for 0x%02hhx\n", aux->verm.c);
-        offset = aux->verm.offset;
-        ptr = vermicelliExec(aux->verm.c, 1, ptr, end);
-        break;
-    case ACCEL_DVERM:
-        DEBUG_PRINTF("double vermicelli for 0x%02hhx%02hhx\n",
-                     aux->dverm.c1, aux->dverm.c2);
-        offset = aux->dverm.offset;
-        ptr = vermicelliDoubleExec(aux->dverm.c1, aux->dverm.c2, 0, ptr, end);
-        break;
-    case ACCEL_DVERM_NOCASE:
-        DEBUG_PRINTF("double vermicelli-nocase for 0x%02hhx%02hhx\n",
-                     aux->dverm.c1, aux->dverm.c2);
-        offset = aux->dverm.offset;
-        ptr = vermicelliDoubleExec(aux->dverm.c1, aux->dverm.c2,
-                                   1, ptr, end);
-        break;
-    case ACCEL_SHUFTI:
-        DEBUG_PRINTF("single shufti\n");
-        offset = aux->shufti.offset;
-        ptr = shuftiExec(aux->shufti.lo, aux->shufti.hi, ptr, end);
-        break;
-    case ACCEL_DSHUFTI:
-        DEBUG_PRINTF("double shufti\n");
-        offset = aux->dshufti.offset;
-        ptr = shuftiDoubleExec(aux->dshufti.lo1, aux->dshufti.hi1,
-                               aux->dshufti.lo2, aux->dshufti.hi2, ptr, end);
-        break;
-    case ACCEL_TRUFFLE:
-        DEBUG_PRINTF("truffle shuffle\n");
-        offset = aux->truffle.offset;
-        ptr = truffleExec(aux->truffle.mask1, aux->truffle.mask2, ptr, end);
-        break;
-    case ACCEL_RED_TAPE:
-        ptr = end; /* there is no escape */
-        offset = aux->generic.offset;
-        break;
-    default:
-        /* no acceleration, fall through and return current ptr */
-        offset = 0;
-        break;
-    }
-
-    if (offset) {
-        ptr -= offset;
-        if (ptr < start) {
-            return start;
-        }
-    }
-
-    return ptr;
-}
-
 static really_inline
 size_t accelScanWrapper(const u8 *accelTable, const union AccelAux *aux,
                         const u8 *input, u32 idx, size_t i, size_t end) {
@@ -134,7 +69,7 @@ size_t accelScanWrapper(const u8 *accelTable, const union AccelAux *aux,
     }
 
     aux = aux + aux_idx;
-    const u8 *ptr = accelScan(aux, &input[i], &input[end]);
+    const u8 *ptr = run_accel(aux, &input[i], &input[end]);
     assert(ptr >= &input[i]);
     size_t j = (size_t)(ptr - input);
     DEBUG_PRINTF("accel skipped %zu of %zu chars\n", (j - i), (end - i));
diff --git a/src/nfa/limex_compile.cpp b/src/nfa/limex_compile.cpp
index a6c34cb6..5d51feb9 100644
--- a/src/nfa/limex_compile.cpp
+++ b/src/nfa/limex_compile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -80,9 +80,11 @@ struct precalcAccel {
     CharReach double_cr;
     flat_set<pair<u8, u8>> double_lits; /* double-byte accel stop literals */
     u32 double_offset;
+
+    MultibyteAccelInfo ma_info;
 };
 
-struct meteor_accel_info {
+struct limex_accel_info {
     ue2::unordered_set<NFAVertex> accelerable;
     map<NFAStateSet, precalcAccel> precalc;
     ue2::unordered_map<NFAVertex, flat_set<NFAVertex> > friends;
@@ -162,7 +164,7 @@ struct build_info {
     bool stateCompression;
     const CompileContext &cc;
     u32 num_states;
-    meteor_accel_info accel;
+    limex_accel_info accel;
 };
 
 // Constants for scoring mechanism
@@ -334,12 +336,16 @@ void buildReachMapping(const build_info &args, vector<NFAStateSet> &reach,
 }
 
 struct AccelBuild {
-    AccelBuild() : v(NFAGraph::null_vertex()), state(0), offset(0) {}
+    AccelBuild() : v(NFAGraph::null_vertex()), state(0), offset(0), ma_len1(0),
+            ma_len2(0), ma_type(MultibyteAccelInfo::MAT_NONE) {}
     NFAVertex v;
     u32 state;
     u32 offset; // offset correction to apply
     CharReach stop1; // single-byte accel stop literals
     flat_set<pair<u8, u8>> stop2; // double-byte accel stop literals
+    u32 ma_len1; // multiaccel len1
+    u32 ma_len2; // multiaccel len2
+    MultibyteAccelInfo::multiaccel_type ma_type; // multiaccel type
 };
 
 static
@@ -354,7 +360,12 @@ void findStopLiterals(const build_info &bi, NFAVertex v, AccelBuild &build) {
         build.stop1 = CharReach::dot();
     } else {
         const precalcAccel &precalc = bi.accel.precalc.at(ss);
-        if (precalc.double_lits.empty()) {
+        unsigned ma_len = precalc.ma_info.len1 + precalc.ma_info.len2;
+        if (ma_len >= MULTIACCEL_MIN_LEN) {
+            build.ma_len1 = precalc.ma_info.len1;
+            build.stop1 = precalc.ma_info.cr;
+            build.offset = precalc.ma_info.offset;
+        } else if (precalc.double_lits.empty()) {
             build.stop1 = precalc.single_cr;
             build.offset = precalc.single_offset;
         } else {
@@ -534,7 +545,7 @@ void filterAccelStates(NGHolder &g, const map<u32, NFAVertex> &tops,
 }
 
 static
-bool containsBadSubset(const meteor_accel_info &accel,
+bool containsBadSubset(const limex_accel_info &accel,
                        const NFAStateSet &state_set, const u32 effective_sds) {
     NFAStateSet subset(state_set.size());
     for (size_t j = state_set.find_first(); j != state_set.npos;
@@ -555,11 +566,29 @@ bool containsBadSubset(const meteor_accel_info &accel,
 }
 
 static
-void doAccelCommon(NGHolder &g,
-                   ue2::unordered_map<NFAVertex, AccelScheme> &accel_map,
-                   const ue2::unordered_map<NFAVertex, u32> &state_ids,
-                   const map<NFAVertex, BoundedRepeatSummary> &br_cyclic,
-                   const u32 num_states, meteor_accel_info *accel) {
+bool is_too_wide(const AccelScheme &as) {
+    return as.cr.count() > MAX_MERGED_ACCEL_STOPS;
+}
+
+static
+void fillAccelInfo(build_info &bi) {
+    if (!bi.do_accel) {
+        return;
+    }
+
+    NGHolder &g = bi.h;
+    limex_accel_info &accel = bi.accel;
+    unordered_map<NFAVertex, AccelScheme> &accel_map = accel.accel_map;
+    const map<NFAVertex, BoundedRepeatSummary> &br_cyclic = bi.br_cyclic;
+    const CompileContext &cc = bi.cc;
+    const unordered_map<NFAVertex, u32> &state_ids = bi.state_ids;
+    const u32 num_states = bi.num_states;
+
+    nfaFindAccelSchemes(g, br_cyclic, &accel_map);
+    filterAccelStates(g, bi.tops, &accel_map);
+
+    assert(accel_map.size() <= NFA_MAX_ACCEL_STATES);
+
     vector<CharReach> refined_cr = reduced_cr(g, br_cyclic);
 
     vector<NFAVertex> astates;
@@ -590,7 +619,7 @@ void doAccelCommon(NGHolder &g,
             }
         }
 
-        if (containsBadSubset(*accel, state_set, effective_sds)) {
+        if (containsBadSubset(accel, state_set, effective_sds)) {
             DEBUG_PRINTF("accel %u has bad subset\n", i);
             continue; /* if a subset failed to build we would too */
         }
@@ -598,30 +627,37 @@ void doAccelCommon(NGHolder &g,
         const bool allow_wide = allow_wide_accel(states, g, sds_or_proxy);
 
         AccelScheme as = nfaFindAccel(g, states, refined_cr, br_cyclic,
-                                      allow_wide);
-        if (as.cr.count() > MAX_MERGED_ACCEL_STOPS) {
+                                      allow_wide, true);
+        if (is_too_wide(as)) {
             DEBUG_PRINTF("accel %u too wide (%zu, %d)\n", i,
                          as.cr.count(), MAX_MERGED_ACCEL_STOPS);
             continue;
         }
 
-        DEBUG_PRINTF("accel %u ok with offset %u\n", i, as.offset);
+        DEBUG_PRINTF("accel %u ok with offset s%u, d%u\n", i, as.offset,
+                     as.double_offset);
 
-        precalcAccel &pa = accel->precalc[state_set];
-        pa.single_offset = as.offset;
-        pa.single_cr = as.cr;
+        // try multibyte acceleration first
+        MultibyteAccelInfo mai = nfaCheckMultiAccel(g, states, cc);
+
+        precalcAccel &pa = accel.precalc[state_set];
         useful |= state_set;
 
-        if (states.size() == 1) {
-            DoubleAccelInfo b = findBestDoubleAccelInfo(g, states.front());
-            if (pa.single_cr.count() > b.stop1.count()) {
-                /* insert this information into the precalc accel info as it is
-                 * better than the single scheme */
-                pa.double_offset = b.offset;
-                pa.double_lits = b.stop2;
-                pa.double_cr = b.stop1;
-            }
+        // if we successfully built a multibyte accel scheme, use that
+        if (mai.type != MultibyteAccelInfo::MAT_NONE) {
+            pa.ma_info = mai;
+
+            DEBUG_PRINTF("multibyte acceleration!\n");
+            continue;
         }
+
+        pa.single_offset = as.offset;
+        pa.single_cr = as.cr;
+        if (as.double_byte.size() != 0) {
+            pa.double_offset = as.double_offset;
+            pa.double_lits = as.double_byte;
+            pa.double_cr = as.double_cr;
+        };
     }
 
     for (const auto &m : accel_map) {
@@ -638,31 +674,22 @@ void doAccelCommon(NGHolder &g,
         state_set.reset();
         state_set.set(state_id);
 
-        auto p_it = accel->precalc.find(state_set);
-        if (p_it != accel->precalc.end()) {
+        bool is_multi = false;
+        auto p_it = accel.precalc.find(state_set);
+        if (p_it != accel.precalc.end()) {
             const precalcAccel &pa = p_it->second;
             offset = max(pa.double_offset, pa.single_offset);
+            is_multi = pa.ma_info.type != MultibyteAccelInfo::MAT_NONE;
             assert(offset <= MAX_ACCEL_DEPTH);
         }
 
-        accel->accelerable.insert(v);
-        findAccelFriends(g, v, br_cyclic, offset, &accel->friends[v]);
+        accel.accelerable.insert(v);
+        if (!is_multi) {
+            findAccelFriends(g, v, br_cyclic, offset, &accel.friends[v]);
+        }
     }
 }
 
-static
-void fillAccelInfo(build_info &bi) {
-    if (!bi.do_accel) {
-        return;
-    }
-
-    nfaFindAccelSchemes(bi.h, bi.br_cyclic, &bi.accel.accel_map);
-    filterAccelStates(bi.h, bi.tops, &bi.accel.accel_map);
-    assert(bi.accel.accel_map.size() <= NFA_MAX_ACCEL_STATES);
-    doAccelCommon(bi.h, bi.accel.accel_map, bi.state_ids, bi.br_cyclic,
-                  bi.num_states, &bi.accel);
-}
-
 /** The AccelAux structure has large alignment specified, and this makes some
  * compilers do odd things unless we specify a custom allocator. */
 typedef vector<AccelAux, AlignedAllocator<AccelAux, alignof(AccelAux)> >
@@ -672,7 +699,7 @@ static
 void buildAccel(const build_info &args, NFAStateSet &accelMask,
                 NFAStateSet &accelFriendsMask, AccelAuxVector &auxvec,
                 vector<u8> &accelTable) {
-    const meteor_accel_info &accel = args.accel;
+    const limex_accel_info &accel = args.accel;
 
     // Init, all zeroes.
     accelMask.resize(args.num_states);
@@ -737,8 +764,16 @@ void buildAccel(const build_info &args, NFAStateSet &accelMask,
 
         if (contains(accel.precalc, states)) {
             const precalcAccel &precalc = accel.precalc.at(states);
-            ainfo.single_offset = precalc.single_offset;
-            ainfo.single_stops = precalc.single_cr;
+            if (precalc.ma_info.type != MultibyteAccelInfo::MAT_NONE) {
+                ainfo.ma_len1 = precalc.ma_info.len1;
+                ainfo.ma_len2 = precalc.ma_info.len2;
+                ainfo.multiaccel_offset = precalc.ma_info.offset;
+                ainfo.multiaccel_stops = precalc.ma_info.cr;
+                ainfo.ma_type = precalc.ma_info.type;
+            } else {
+                ainfo.single_offset = precalc.single_offset;
+                ainfo.single_stops = precalc.single_cr;
+            }
         }
 
         buildAccelAux(ainfo, &aux);
@@ -2152,7 +2187,7 @@ u32 countAccelStates(NGHolder &h,
 
     if (!cc.grey.allowLimExNFA) {
         DEBUG_PRINTF("limex not allowed\n");
-        return NFA_MAX_ACCEL_STATES + 1;
+        return 0;
     }
 
     // Sanity check the input data.
@@ -2166,11 +2201,11 @@ u32 countAccelStates(NGHolder &h,
                   do_accel, state_compression, cc, num_states);
 
     // Acceleration analysis.
-    fillAccelInfo(bi);
+    nfaFindAccelSchemes(bi.h, bi.br_cyclic, &bi.accel.accel_map);
 
-    u32 num_accel = verify_u32(bi.accel.accelerable.size());
+    u32 num_accel = verify_u32(bi.accel.accel_map.size());
     DEBUG_PRINTF("found %u accel states\n", num_accel);
-    return min(num_accel, (u32)NFA_MAX_ACCEL_STATES);
+    return num_accel;
 }
 
 } // namespace ue2
diff --git a/src/nfa/limex_compile.h b/src/nfa/limex_compile.h
index 0e3fdea0..62a07e10 100644
--- a/src/nfa/limex_compile.h
+++ b/src/nfa/limex_compile.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -79,11 +79,10 @@ aligned_unique_ptr<NFA> generate(NGHolder &g,
                         const CompileContext &cc);
 
 /**
- * \brief For a given graph, count the number of accel states it will have in
- * an implementation.
+ * \brief For a given graph, count the number of accelerable states it has.
  *
- * \return the number of accel states, or NFA_MAX_ACCEL_STATES + 1 if an
- * implementation would not be constructible.
+ * Note that this number may be greater than the number that are actually
+ * implementable.
  */
 u32 countAccelStates(NGHolder &h,
                      const ue2::unordered_map<NFAVertex, u32> &states,
diff --git a/src/nfa/limex_runtime.h b/src/nfa/limex_runtime.h
index 31484256..4e111aa6 100644
--- a/src/nfa/limex_runtime.h
+++ b/src/nfa/limex_runtime.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -42,7 +42,6 @@
 #include "limex_internal.h"
 #include "nfa_api_util.h"
 #include "nfa_internal.h"
-#include "scratch.h"
 #include "util/uniform_ops.h"
 
 ////////////////////////////////////////////////////////////////////////////
diff --git a/src/nfa/limex_runtime_impl.h b/src/nfa/limex_runtime_impl.h
index 6ef3bae9..676ed370 100644
--- a/src/nfa/limex_runtime_impl.h
+++ b/src/nfa/limex_runtime_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -176,8 +176,6 @@ char STREAM_FN(const IMPL_NFA_T *limex, const u8 *input, size_t length,
     const EXCEPTION_T *exceptions = getExceptionTable(EXCEPTION_T, limex);
     const ReportID *exReports = getExReports(limex);
     const u32 *exceptionMap = limex->exceptionMap;
-    assert(ISALIGNED_CL(ctx));
-    assert(ISALIGNED_CL(&ctx->s));
     STATE_T s = LOAD_STATE(&ctx->s);
 
     /* assert(ISALIGNED_16(exceptions)); */
@@ -533,17 +531,17 @@ char JOIN(LIMEX_API_ROOT, _Q)(const struct NFA *n, struct mq *q, s64a end) {
 
     assert(q->cur + 1 < q->end); /* require at least two items */
 
-    struct CONTEXT_T *ctx = q->scratch->nfaContext;
-    assert(ISALIGNED_CL(ctx));
-    ctx->repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T));
-    ctx->repeat_state = q->streamState + limex->stateSize;
-    ctx->callback = q->cb;
-    ctx->context = q->context;
-    STORE_STATE(&ctx->cached_estate, ZERO_STATE);
+    struct CONTEXT_T ctx;
+    ctx.repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T));
+    ctx.repeat_state = q->streamState + limex->stateSize;
+    ctx.callback = q->cb;
+    ctx.context = q->context;
+    STORE_STATE(&ctx.cached_estate, ZERO_STATE);
+    ctx.cached_br = 0;
 
     assert(q->items[q->cur].location >= 0);
     DEBUG_PRINTF("LOAD STATE\n");
-    STORE_STATE(&ctx->s, LOAD_STATE(q->state));
+    STORE_STATE(&ctx.s, LOAD_STATE(q->state));
     assert(q->items[q->cur].type == MQE_START);
 
     u64a offset = q->offset;
@@ -565,7 +563,7 @@ char JOIN(LIMEX_API_ROOT, _Q)(const struct NFA *n, struct mq *q, s64a end) {
         /* do main buffer region */
         DEBUG_PRINTF("MAIN BUFFER SCAN\n");
         assert(ep - offset <= q->length);
-        if (STREAMCB_FN(limex, q->buffer + sp - offset, ep - sp, ctx, sp)
+        if (STREAMCB_FN(limex, q->buffer + sp - offset, ep - sp, &ctx, sp)
                 == MO_HALT_MATCHING) {
             STORE_STATE(q->state, ZERO_STATE);
             return 0;
@@ -584,19 +582,19 @@ char JOIN(LIMEX_API_ROOT, _Q)(const struct NFA *n, struct mq *q, s64a end) {
            q->items[q->cur].type = MQE_START;
            q->items[q->cur].location = sp - offset;
            DEBUG_PRINTF("bailing q->cur %u q->end %u\n", q->cur, q->end);
-           STORE_STATE(q->state, LOAD_STATE(&ctx->s));
+           STORE_STATE(q->state, LOAD_STATE(&ctx.s));
            return MO_ALIVE;
        }
 
-        JOIN(LIMEX_API_ROOT, _HandleEvent)(limex, q, ctx, sp);
+        JOIN(LIMEX_API_ROOT, _HandleEvent)(limex, q, &ctx, sp);
 
         q->cur++;
     }
 
-    EXPIRE_ESTATE_FN(limex, ctx, sp);
+    EXPIRE_ESTATE_FN(limex, &ctx, sp);
 
     DEBUG_PRINTF("END\n");
-    STORE_STATE(q->state, LOAD_STATE(&ctx->s));
+    STORE_STATE(q->state, LOAD_STATE(&ctx.s));
 
     if (q->cur != q->end) {
         q->cur--;
@@ -605,7 +603,7 @@ char JOIN(LIMEX_API_ROOT, _Q)(const struct NFA *n, struct mq *q, s64a end) {
         return MO_ALIVE;
     }
 
-    return ISNONZERO_STATE(LOAD_STATE(&ctx->s));
+    return ISNONZERO_STATE(LOAD_STATE(&ctx.s));
 }
 
 /* used by suffix execution in Rose */
@@ -628,16 +626,16 @@ char JOIN(LIMEX_API_ROOT, _Q2)(const struct NFA *n, struct mq *q, s64a end) {
 
     assert(q->cur + 1 < q->end); /* require at least two items */
 
-    struct CONTEXT_T *ctx = q->scratch->nfaContext;
-    assert(ISALIGNED_CL(ctx));
-    ctx->repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T));
-    ctx->repeat_state = q->streamState + limex->stateSize;
-    ctx->callback = q->cb;
-    ctx->context = q->context;
-    STORE_STATE(&ctx->cached_estate, ZERO_STATE);
+    struct CONTEXT_T ctx;
+    ctx.repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T));
+    ctx.repeat_state = q->streamState + limex->stateSize;
+    ctx.callback = q->cb;
+    ctx.context = q->context;
+    STORE_STATE(&ctx.cached_estate, ZERO_STATE);
+    ctx.cached_br = 0;
 
     DEBUG_PRINTF("LOAD STATE\n");
-    STORE_STATE(&ctx->s, LOAD_STATE(q->state));
+    STORE_STATE(&ctx.s, LOAD_STATE(q->state));
     assert(q->items[q->cur].type == MQE_START);
 
     u64a offset = q->offset;
@@ -661,7 +659,7 @@ char JOIN(LIMEX_API_ROOT, _Q2)(const struct NFA *n, struct mq *q, s64a end) {
         /* do main buffer region */
         u64a final_look = 0;
         assert(ep - offset <= q->length);
-        if (STREAMFIRST_FN(limex, q->buffer + sp - offset, ep - sp, ctx, sp,
+        if (STREAMFIRST_FN(limex, q->buffer + sp - offset, ep - sp, &ctx, sp,
                            &final_look) == MO_HALT_MATCHING) {
             DEBUG_PRINTF("final_look:%llu sp:%llu end_abs:%llu offset:%llu\n",
                          final_look, sp, end_abs, offset);
@@ -669,7 +667,7 @@ char JOIN(LIMEX_API_ROOT, _Q2)(const struct NFA *n, struct mq *q, s64a end) {
             q->cur--;
             q->items[q->cur].type = MQE_START;
             q->items[q->cur].location = sp + final_look - offset;
-            STORE_STATE(q->state, LOAD_STATE(&ctx->s));
+            STORE_STATE(q->state, LOAD_STATE(&ctx.s));
             return MO_MATCHES_PENDING;
         }
 
@@ -685,19 +683,19 @@ char JOIN(LIMEX_API_ROOT, _Q2)(const struct NFA *n, struct mq *q, s64a end) {
             q->items[q->cur].type = MQE_START;
             q->items[q->cur].location = sp - offset;
             DEBUG_PRINTF("bailing q->cur %u q->end %u\n", q->cur, q->end);
-            STORE_STATE(q->state, LOAD_STATE(&ctx->s));
+            STORE_STATE(q->state, LOAD_STATE(&ctx.s));
             return MO_ALIVE;
         }
 
-        JOIN(LIMEX_API_ROOT, _HandleEvent)(limex, q, ctx, sp);
+        JOIN(LIMEX_API_ROOT, _HandleEvent)(limex, q, &ctx, sp);
 
         q->cur++;
     }
 
-    EXPIRE_ESTATE_FN(limex, ctx, sp);
+    EXPIRE_ESTATE_FN(limex, &ctx, sp);
 
     DEBUG_PRINTF("END\n");
-    STORE_STATE(q->state, LOAD_STATE(&ctx->s));
+    STORE_STATE(q->state, LOAD_STATE(&ctx.s));
 
     if (q->cur != q->end) {
         q->cur--;
@@ -706,7 +704,7 @@ char JOIN(LIMEX_API_ROOT, _Q2)(const struct NFA *n, struct mq *q, s64a end) {
         return MO_ALIVE;
     }
 
-    return ISNONZERO_STATE(LOAD_STATE(&ctx->s));
+    return ISNONZERO_STATE(LOAD_STATE(&ctx.s));
 }
 
 // Used for execution Rose prefix/infixes.
@@ -720,15 +718,16 @@ char JOIN(LIMEX_API_ROOT, _QR)(const struct NFA *n, struct mq *q,
 
     assert(q->cur + 1 < q->end); /* require at least two items */
 
-    struct CONTEXT_T *ctx = q->scratch->nfaContext;
-    ctx->repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T));
-    ctx->repeat_state = q->streamState + limex->stateSize;
-    ctx->callback = NULL;
-    ctx->context = NULL;
-    STORE_STATE(&ctx->cached_estate, ZERO_STATE);
+    struct CONTEXT_T ctx;
+    ctx.repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T));
+    ctx.repeat_state = q->streamState + limex->stateSize;
+    ctx.callback = NULL;
+    ctx.context = NULL;
+    STORE_STATE(&ctx.cached_estate, ZERO_STATE);
+    ctx.cached_br = 0;
 
     DEBUG_PRINTF("LOAD STATE\n");
-    STORE_STATE(&ctx->s, LOAD_STATE(q->state));
+    STORE_STATE(&ctx.s, LOAD_STATE(q->state));
     assert(q->items[q->cur].type == MQE_START);
 
     u64a offset = q->offset;
@@ -740,7 +739,7 @@ char JOIN(LIMEX_API_ROOT, _QR)(const struct NFA *n, struct mq *q,
         if (n->maxWidth) {
             if (ep - sp > n->maxWidth) {
                 sp = ep - n->maxWidth;
-                STORE_STATE(&ctx->s, INITIAL_FN(limex, !!sp));
+                STORE_STATE(&ctx.s, INITIAL_FN(limex, !!sp));
             }
         }
         assert(ep >= sp);
@@ -751,7 +750,7 @@ char JOIN(LIMEX_API_ROOT, _QR)(const struct NFA *n, struct mq *q,
             u64a local_ep = MIN(offset, ep);
             /* we are starting inside the history buffer */
             STREAMSILENT_FN(limex, q->history + q->hlength + sp - offset,
-                            local_ep - sp, ctx, sp);
+                            local_ep - sp, &ctx, sp);
 
             sp = local_ep;
         }
@@ -763,30 +762,30 @@ char JOIN(LIMEX_API_ROOT, _QR)(const struct NFA *n, struct mq *q,
         /* do main buffer region */
         DEBUG_PRINTF("MAIN BUFFER SCAN\n");
         assert(ep - offset <= q->length);
-        STREAMSILENT_FN(limex, q->buffer + sp - offset, ep - sp, ctx, sp);
+        STREAMSILENT_FN(limex, q->buffer + sp - offset, ep - sp, &ctx, sp);
 
         DEBUG_PRINTF("SCAN DONE\n");
     scan_done:
         sp = ep;
 
-        JOIN(LIMEX_API_ROOT, _HandleEvent)(limex, q, ctx, sp);
+        JOIN(LIMEX_API_ROOT, _HandleEvent)(limex, q, &ctx, sp);
 
         q->cur++;
     }
 
-    EXPIRE_ESTATE_FN(limex, ctx, sp);
+    EXPIRE_ESTATE_FN(limex, &ctx, sp);
 
     DEBUG_PRINTF("END, nfa is %s\n",
-                 ISNONZERO_STATE(ctx->s) ? "still alive" : "dead");
+                 ISNONZERO_STATE(ctx.s) ? "still alive" : "dead");
 
-    STORE_STATE(q->state, LOAD_STATE(&ctx->s));
+    STORE_STATE(q->state, LOAD_STATE(&ctx.s));
 
-    if (JOIN(limexInAccept, SIZE)(limex, LOAD_STATE(&ctx->s), ctx->repeat_ctrl,
-                                  ctx->repeat_state, sp + 1, report)) {
+    if (JOIN(limexInAccept, SIZE)(limex, LOAD_STATE(&ctx.s), ctx.repeat_ctrl,
+                                  ctx.repeat_state, sp + 1, report)) {
         return MO_MATCHES_PENDING;
     }
 
-    return ISNONZERO_STATE(LOAD_STATE(&ctx->s));
+    return ISNONZERO_STATE(LOAD_STATE(&ctx.s));
 }
 
 char JOIN(LIMEX_API_ROOT, _testEOD)(const struct NFA *n, const char *state,
@@ -813,42 +812,40 @@ char JOIN(LIMEX_API_ROOT, _reportCurrent)(const struct NFA *n, struct mq *q) {
 
 // Block mode reverse scan.
 char JOIN(LIMEX_API_ROOT, _B_Reverse)(const struct NFA *n, u64a offset,
-                                         const u8 *buf, size_t buflen,
-                                         const u8 *hbuf, size_t hlen,
-                                         struct hs_scratch *scratch,
-                                         NfaCallback cb, void *context) {
+                                      const u8 *buf, size_t buflen,
+                                      const u8 *hbuf, size_t hlen,
+                                      NfaCallback cb, void *context) {
     assert(buf || hbuf);
     assert(buflen || hlen);
 
-    /* This may be called INSIDE another NFA, so we need a separate
-     * context --> Hence the nfaContextSom */
-    struct CONTEXT_T *ctx = scratch->nfaContextSom;
-    ctx->repeat_ctrl = NULL;
-    ctx->repeat_state = NULL;
-    ctx->callback = cb;
-    ctx->context = context;
-    STORE_STATE(&ctx->cached_estate, ZERO_STATE);
+    struct CONTEXT_T ctx;
+    ctx.repeat_ctrl = NULL;
+    ctx.repeat_state = NULL;
+    ctx.callback = cb;
+    ctx.context = context;
+    STORE_STATE(&ctx.cached_estate, ZERO_STATE);
+    ctx.cached_br = 0;
 
     const IMPL_NFA_T *limex = getImplNfa(n);
-    STORE_STATE(&ctx->s, INITIAL_FN(limex, 0)); // always anchored
+    STORE_STATE(&ctx.s, INITIAL_FN(limex, 0)); // always anchored
 
     // 'buf' may be null, for example when we're scanning at EOD time.
     if (buflen) {
         assert(buf);
         DEBUG_PRINTF("MAIN BUFFER SCAN, %zu bytes\n", buflen);
         offset -= buflen;
-        REV_STREAM_FN(limex, buf, buflen, ctx, offset);
+        REV_STREAM_FN(limex, buf, buflen, &ctx, offset);
     }
 
     if (hlen) {
         assert(hbuf);
         DEBUG_PRINTF("HISTORY BUFFER SCAN, %zu bytes\n", hlen);
         offset -= hlen;
-        REV_STREAM_FN(limex, hbuf, hlen, ctx, offset);
+        REV_STREAM_FN(limex, hbuf, hlen, &ctx, offset);
     }
 
-    if (offset == 0 && ISNONZERO_STATE(LOAD_STATE(&ctx->s))) {
-        TESTEOD_REV_FN(limex, &ctx->s, offset, cb, context);
+    if (offset == 0 && ISNONZERO_STATE(LOAD_STATE(&ctx.s))) {
+        TESTEOD_REV_FN(limex, &ctx.s, offset, cb, context);
     }
 
     // NOTE: return value is unused.
diff --git a/src/nfa/mcclellan.c b/src/nfa/mcclellan.c
index 694196e6..314e88e7 100644
--- a/src/nfa/mcclellan.c
+++ b/src/nfa/mcclellan.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -445,14 +445,15 @@ char mcclellanExec8_i_ni(const struct mcclellan *m, u8 *state, const u8 *buf,
 }
 
 static really_inline
-void mcclellanCheckEOD(const struct NFA *nfa, u16 s, u64a offset,
+char mcclellanCheckEOD(const struct NFA *nfa, u16 s, u64a offset,
                        NfaCallback cb, void *ctxt) {
     const struct mcclellan *m = getImplNfa(nfa);
     const struct mstate_aux *aux = get_aux(m, s);
 
-    if (aux->accept_eod) {
-        doComplexReport(cb, ctxt, m, s, offset, 1, NULL, NULL);
+    if (!aux->accept_eod) {
+        return MO_CONTINUE_MATCHING;
     }
+    return doComplexReport(cb, ctxt, m, s, offset, 1, NULL, NULL);
 }
 
 static really_inline
@@ -1019,42 +1020,44 @@ void nfaExecMcClellan8_SimpStream(const struct NFA *nfa, char *state,
                                   const u8 *buf, char top, size_t start_off,
                                   size_t len, NfaCallback cb, void *ctxt) {
     const struct mcclellan *m = (const struct mcclellan *)getImplNfa(nfa);
-    if (top) {
-        *(u8 *)state = m->start_anchored;
-    }
+
+    u8 s = top ? m->start_anchored : *(u8 *)state;
 
     if (m->flags & MCCLELLAN_FLAG_SINGLE) {
-        mcclellanExec8_i(m, (u8 *)state, buf + start_off, len - start_off,
+        mcclellanExec8_i(m, &s, buf + start_off, len - start_off,
                          start_off, cb, ctxt, 1, NULL, CALLBACK_OUTPUT);
     } else {
-        mcclellanExec8_i(m, (u8 *)state, buf + start_off, len - start_off,
+        mcclellanExec8_i(m, &s, buf + start_off, len - start_off,
                          start_off, cb, ctxt, 0, NULL, CALLBACK_OUTPUT);
     }
+
+    *(u8 *)state = s;
 }
 
 void nfaExecMcClellan16_SimpStream(const struct NFA *nfa, char *state,
                                    const u8 *buf, char top, size_t start_off,
                                    size_t len, NfaCallback cb, void *ctxt) {
     const struct mcclellan *m = (const struct mcclellan *)getImplNfa(nfa);
-    if (top) {
-        *(u16 *)state = m->start_anchored;
-    }
+
+    u16 s = top ? m->start_anchored : unaligned_load_u16(state);
 
     if (m->flags & MCCLELLAN_FLAG_SINGLE) {
-        mcclellanExec16_i(m, (u16 *)state, buf + start_off, len - start_off,
+        mcclellanExec16_i(m, &s, buf + start_off, len - start_off,
                          start_off, cb, ctxt, 1, NULL, CALLBACK_OUTPUT);
     } else {
-        mcclellanExec16_i(m, (u16 *)state, buf + start_off, len - start_off,
+        mcclellanExec16_i(m, &s, buf + start_off, len - start_off,
                          start_off, cb, ctxt, 0, NULL, CALLBACK_OUTPUT);
     }
+
+    unaligned_store_u16(state, s);
 }
 
 char nfaExecMcClellan8_testEOD(const struct NFA *nfa, const char *state,
                                UNUSED const char *streamState,
                                u64a offset, NfaCallback callback,
                                UNUSED SomNfaCallback som_cb, void *context) {
-    mcclellanCheckEOD(nfa, *(const u8 *)state, offset, callback, context);
-    return 0;
+    return mcclellanCheckEOD(nfa, *(const u8 *)state, offset, callback,
+                             context);
 }
 
 char nfaExecMcClellan16_testEOD(const struct NFA *nfa, const char *state,
@@ -1062,8 +1065,8 @@ char nfaExecMcClellan16_testEOD(const struct NFA *nfa, const char *state,
                                 u64a offset, NfaCallback callback,
                                 UNUSED SomNfaCallback som_cb, void *context) {
     assert(ISALIGNED_N(state, 2));
-    mcclellanCheckEOD(nfa, *(const u16 *)state, offset, callback, context);
-    return 0;
+    return mcclellanCheckEOD(nfa, *(const u16 *)state, offset, callback,
+                             context);
 }
 
 char nfaExecMcClellan8_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) {
diff --git a/src/nfa/mcclellancompile.cpp b/src/nfa/mcclellancompile.cpp
index f75d08b5..a9fbce94 100644
--- a/src/nfa/mcclellancompile.cpp
+++ b/src/nfa/mcclellancompile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -29,8 +29,11 @@
 #include "mcclellancompile.h"
 
 #include "accel.h"
+#include "accelcompile.h"
 #include "grey.h"
 #include "mcclellan_internal.h"
+#include "mcclellancompile_accel.h"
+#include "mcclellancompile_util.h"
 #include "nfa_internal.h"
 #include "shufticompile.h"
 #include "trufflecompile.h"
@@ -43,6 +46,7 @@
 #include "util/container.h"
 #include "util/make_unique.h"
 #include "util/order_check.h"
+#include "util/report_manager.h"
 #include "util/ue2_containers.h"
 #include "util/unaligned.h"
 #include "util/verify_types.h"
@@ -56,25 +60,18 @@
 #include <set>
 #include <vector>
 
+#include <boost/range/adaptor/map.hpp>
+
 using namespace std;
+using boost::adaptors::map_keys;
 
 namespace ue2 {
 
-/* compile time accel defs */
-#define ACCEL_MAX_STOP_CHAR 160 /* larger than nfa, as we don't have a budget
-                                   and the nfa cheats on stop characters for
-                                   sets of states */
-#define ACCEL_MAX_FLOATING_STOP_CHAR 192 /* accelerating sds is important */
-
-
 namespace /* anon */ {
 
 struct dstate_extra {
-    u16 daddytaken;
-    bool shermanState;
-    bool accelerable;
-    dstate_extra(void) : daddytaken(0), shermanState(false),
-                         accelerable(false) {}
+    u16 daddytaken = 0;
+    bool shermanState = false;
 };
 
 struct dfa_info {
@@ -105,10 +102,6 @@ struct dfa_info {
         return extra[raw_id].shermanState;
     }
 
-    bool is_accel(dstate_id_t raw_id) const {
-        return extra[raw_id].accelerable;
-    }
-
     size_t size(void) const { return states.size(); }
 };
 
@@ -135,6 +128,13 @@ mstate_aux *getAux(NFA *n, dstate_id_t i) {
     return aux;
 }
 
+static
+bool double_byte_ok(const AccelScheme &info) {
+    return !info.double_byte.empty()
+        && info.double_cr.count() < info.double_byte.size()
+        && info.double_cr.count() <= 2 && !info.double_byte.empty();
+}
+
 static
 void markEdges(NFA *n, u16 *succ_table, const dfa_info &info) {
     assert((size_t)succ_table % 2 == 0);
@@ -186,75 +186,45 @@ void markEdges(NFA *n, u16 *succ_table, const dfa_info &info) {
     }
 }
 
-void mcclellan_build_strat::find_escape_strings(dstate_id_t this_idx,
-                                                escape_info *out) const {
-    const dstate &raw = rdfa.states[this_idx];
-    const auto &alpha_remap = rdfa.alpha_remap;
+u32 mcclellan_build_strat::max_allowed_offset_accel() const {
+    return ACCEL_DFA_MAX_OFFSET_DEPTH;
+}
 
-    flat_set<pair<u8, u8>> outs2_local;
-    for (unsigned i = 0; i < N_CHARS; i++) {
-        outs2_local.clear();
-
-        if (raw.next[alpha_remap[i]] != this_idx) {
-            out->outs.set(i);
-
-            DEBUG_PRINTF("next is %hu\n", raw.next[alpha_remap[i]]);
-            const dstate &raw_next = rdfa.states[raw.next[alpha_remap[i]]];
-
-            if (!raw_next.reports.empty() && generates_callbacks(rdfa.kind)) {
-                DEBUG_PRINTF("leads to report\n");
-                out->outs2_broken = true;  /* cannot accelerate over reports */
-            }
-
-            for (unsigned j = 0; !out->outs2_broken && j < N_CHARS; j++) {
-                if (raw_next.next[alpha_remap[j]] == raw.next[alpha_remap[j]]) {
-                    continue;
-                }
-
-                DEBUG_PRINTF("adding %02x %02x -> %hu to 2 \n", i, j,
-                             raw_next.next[alpha_remap[j]]);
-                outs2_local.emplace((u8)i, (u8)j);
-            }
-
-            if (outs2_local.size() > 8) {
-                DEBUG_PRINTF("adding %02x to outs2_single\n", i);
-                out->outs2_single.set(i);
-            } else {
-                insert(&out->outs2, outs2_local);
-            }
-            if (out->outs2.size() > 8) {
-                DEBUG_PRINTF("outs2 too big\n");
-                out->outs2_broken = true;
-            }
-        }
-    }
+AccelScheme mcclellan_build_strat::find_escape_strings(dstate_id_t this_idx)
+    const {
+    return find_mcclellan_escape_info(rdfa, this_idx,
+                                      max_allowed_offset_accel());
 }
 
 /** builds acceleration schemes for states */
-void mcclellan_build_strat::buildAccel(dstate_id_t this_idx, void *accel_out) {
+void mcclellan_build_strat::buildAccel(UNUSED dstate_id_t this_idx,
+                                       const AccelScheme &info,
+                                       void *accel_out) {
     AccelAux *accel = (AccelAux *)accel_out;
-    escape_info out;
 
-    find_escape_strings(this_idx, &out);
+    DEBUG_PRINTF("accelerations scheme has offset s%u/d%u\n", info.offset,
+                 info.double_offset);
+    accel->generic.offset = verify_u8(info.offset);
 
-    if (!out.outs2_broken && out.outs2_single.none()
-        && out.outs2.size() == 1) {
+    if (double_byte_ok(info) && info.double_cr.none()
+        && info.double_byte.size() == 1) {
         accel->accel_type = ACCEL_DVERM;
-        accel->dverm.c1 = out.outs2.begin()->first;
-        accel->dverm.c2 = out.outs2.begin()->second;
+        accel->dverm.c1 = info.double_byte.begin()->first;
+        accel->dverm.c2 = info.double_byte.begin()->second;
+        accel->dverm.offset = verify_u8(info.double_offset);
         DEBUG_PRINTF("state %hu is double vermicelli\n", this_idx);
         return;
     }
 
-    if (!out.outs2_broken && out.outs2_single.none()
-        && (out.outs2.size() == 2 || out.outs2.size() == 4)) {
+    if (double_byte_ok(info) && info.double_cr.none()
+        && (info.double_byte.size() == 2 || info.double_byte.size() == 4)) {
         bool ok = true;
 
-        assert(!out.outs2.empty());
-        u8 firstC = out.outs2.begin()->first & CASE_CLEAR;
-        u8 secondC = out.outs2.begin()->second & CASE_CLEAR;
+        assert(!info.double_byte.empty());
+        u8 firstC = info.double_byte.begin()->first & CASE_CLEAR;
+        u8 secondC = info.double_byte.begin()->second & CASE_CLEAR;
 
-        for (const pair<u8, u8> &p : out.outs2) {
+        for (const pair<u8, u8> &p : info.double_byte) {
             if ((p.first & CASE_CLEAR) != firstC
              || (p.second & CASE_CLEAR) != secondC) {
                 ok = false;
@@ -266,185 +236,76 @@ void mcclellan_build_strat::buildAccel(dstate_id_t this_idx, void *accel_out) {
             accel->accel_type = ACCEL_DVERM_NOCASE;
             accel->dverm.c1 = firstC;
             accel->dverm.c2 = secondC;
+            accel->dverm.offset = verify_u8(info.double_offset);
             DEBUG_PRINTF("state %hu is nc double vermicelli\n", this_idx);
             return;
         }
+
+        u8 m1;
+        u8 m2;
+        if (buildDvermMask(info.double_byte, &m1, &m2)) {
+            accel->accel_type = ACCEL_DVERM_MASKED;
+            accel->dverm.offset = verify_u8(info.double_offset);
+            accel->dverm.c1 = info.double_byte.begin()->first & m1;
+            accel->dverm.c2 = info.double_byte.begin()->second & m2;
+            accel->dverm.m1 = m1;
+            accel->dverm.m2 = m2;
+            DEBUG_PRINTF("building maskeddouble-vermicelli for 0x%02hhx%02hhx\n",
+                         accel->dverm.c1, accel->dverm.c2);
+            return;
+        }
     }
 
-    if (!out.outs2_broken &&
-        (out.outs2_single.count() + out.outs2.size()) <= 8 &&
-        out.outs2_single.count() < out.outs2.size() &&
-        out.outs2_single.count() <= 2 && !out.outs2.empty()) {
+    if (double_byte_ok(info)
+        && shuftiBuildDoubleMasks(info.double_cr, info.double_byte,
+                                  &accel->dshufti.lo1, &accel->dshufti.hi1,
+                                  &accel->dshufti.lo2, &accel->dshufti.hi2)) {
         accel->accel_type = ACCEL_DSHUFTI;
-        shuftiBuildDoubleMasks(out.outs2_single, out.outs2,
-                               &accel->dshufti.lo1,
-                               &accel->dshufti.hi1,
-                               &accel->dshufti.lo2,
-                               &accel->dshufti.hi2);
+        accel->dshufti.offset = verify_u8(info.double_offset);
         DEBUG_PRINTF("state %hu is double shufti\n", this_idx);
         return;
     }
 
-    if (out.outs.none()) {
+    if (info.cr.none()) {
         accel->accel_type = ACCEL_RED_TAPE;
         DEBUG_PRINTF("state %hu is a dead end full of bureaucratic red tape"
                      " from which there is no escape\n", this_idx);
         return;
     }
 
-    if (out.outs.count() == 1) {
+    if (info.cr.count() == 1) {
         accel->accel_type = ACCEL_VERM;
-        accel->verm.c = out.outs.find_first();
+        accel->verm.c = info.cr.find_first();
         DEBUG_PRINTF("state %hu is vermicelli\n", this_idx);
         return;
     }
 
-    if (out.outs.count() == 2 && out.outs.isCaselessChar()) {
+    if (info.cr.count() == 2 && info.cr.isCaselessChar()) {
         accel->accel_type = ACCEL_VERM_NOCASE;
-        accel->verm.c = out.outs.find_first() & CASE_CLEAR;
+        accel->verm.c = info.cr.find_first() & CASE_CLEAR;
         DEBUG_PRINTF("state %hu is caseless vermicelli\n", this_idx);
         return;
     }
 
-    if (out.outs.count() > ACCEL_MAX_FLOATING_STOP_CHAR) {
+    if (info.cr.count() > ACCEL_DFA_MAX_FLOATING_STOP_CHAR) {
         accel->accel_type = ACCEL_NONE;
         DEBUG_PRINTF("state %hu is too broad\n", this_idx);
         return;
     }
 
     accel->accel_type = ACCEL_SHUFTI;
-    if (-1 != shuftiBuildMasks(out.outs, &accel->shufti.lo,
+    if (-1 != shuftiBuildMasks(info.cr, &accel->shufti.lo,
                                &accel->shufti.hi)) {
         DEBUG_PRINTF("state %hu is shufti\n", this_idx);
         return;
     }
 
-    assert(!out.outs.none());
+    assert(!info.cr.none());
     accel->accel_type = ACCEL_TRUFFLE;
-    truffleBuildMasks(out.outs, &accel->truffle.mask1, &accel->truffle.mask2);
+    truffleBuildMasks(info.cr, &accel->truffle.mask1, &accel->truffle.mask2);
     DEBUG_PRINTF("state %hu is truffle\n", this_idx);
 }
 
-static
-bool is_accel(const raw_dfa &raw, dstate_id_t sds_or_proxy,
-              dstate_id_t this_idx) {
-    if (!this_idx /* dead state is not accelerable */) {
-        return false;
-    }
-
-    /* Note on report acceleration states: While we can't accelerate while we
-     * are spamming out callbacks, the QR code paths don't raise reports
-     * during scanning so they can accelerate report states. */
-
-    if (generates_callbacks(raw.kind)
-        && !raw.states[this_idx].reports.empty()) {
-        return false;
-    }
-
-    size_t single_limit = this_idx == sds_or_proxy ?
-                             ACCEL_MAX_FLOATING_STOP_CHAR : ACCEL_MAX_STOP_CHAR;
-    DEBUG_PRINTF("inspecting %hu/%hu: %zu\n", this_idx, sds_or_proxy,
-                  single_limit);
-
-    CharReach out;
-    for (u32 i = 0; i < N_CHARS; i++) {
-        if (raw.states[this_idx].next[raw.alpha_remap[i]] != this_idx) {
-            out.set(i);
-        }
-    }
-
-    if (out.count() <= single_limit) {
-        DEBUG_PRINTF("state %hu should be accelerable %zu\n", this_idx,
-                     out.count());
-        return true;
-    }
-
-    DEBUG_PRINTF("state %hu is not accelerable has %zu\n", this_idx,
-                  out.count());
-
-    return false;
-}
-
-static
-bool has_self_loop(dstate_id_t s, const raw_dfa &raw) {
-    u16 top_remap = raw.alpha_remap[TOP];
-    for (u32 i = 0; i < raw.states[s].next.size(); i++) {
-        if (i != top_remap && raw.states[s].next[i] == s) {
-            return true;
-        }
-    }
-    return false;
-}
-
-static
-dstate_id_t get_sds_or_proxy(const raw_dfa &raw) {
-    if (raw.start_floating != DEAD_STATE) {
-        DEBUG_PRINTF("has floating start\n");
-        return raw.start_floating;
-    }
-
-    DEBUG_PRINTF("looking for SDS proxy\n");
-
-    dstate_id_t s = raw.start_anchored;
-
-    if (has_self_loop(s, raw)) {
-        return s;
-    }
-
-    u16 top_remap = raw.alpha_remap[TOP];
-
-    ue2::unordered_set<dstate_id_t> seen;
-    while (true) {
-        seen.insert(s);
-        DEBUG_PRINTF("basis %hu\n", s);
-
-        /* check if we are connected to a state with a self loop */
-        for (u32 i = 0; i < raw.states[s].next.size(); i++) {
-            dstate_id_t t = raw.states[s].next[i];
-            if (i != top_remap && t != DEAD_STATE && has_self_loop(t, raw)) {
-                return t;
-            }
-        }
-
-        /* find a neighbour to use as a basis for looking for the sds proxy */
-        dstate_id_t t = DEAD_STATE;
-        for (u32 i = 0; i < raw.states[s].next.size(); i++) {
-            dstate_id_t tt = raw.states[s].next[i];
-            if (i != top_remap && tt != DEAD_STATE && !contains(seen, tt)) {
-                t = tt;
-                break;
-            }
-        }
-
-        if (t == DEAD_STATE) {
-            /* we were unable to find a state to use as a SDS proxy */
-            return DEAD_STATE;
-        }
-
-        s = t;
-        seen.insert(t);
-    }
-}
-
-static
-void populateAccelerationInfo(dfa_info &info, u32 *ac, const Grey &grey) {
-    *ac = 0; /* number of accelerable states */
-
-    if (!grey.accelerateDFA) {
-        return;
-    }
-
-    dstate_id_t sds_proxy = get_sds_or_proxy(info.raw);
-    DEBUG_PRINTF("sds %hu\n", sds_proxy);
-
-    for (size_t i = 0; i < info.size(); i++) {
-        if (is_accel(info.raw, sds_proxy, i)) {
-            ++*ac;
-            info.extra[i].accelerable = true;
-        }
-    }
-}
-
 static
 void populateBasicInfo(size_t state_size, const dfa_info &info,
                        u32 total_size, u32 aux_offset, u32 accel_offset,
@@ -496,8 +357,16 @@ namespace {
 struct raw_report_list {
     flat_set<ReportID> reports;
 
-    explicit raw_report_list(const flat_set<ReportID> &reports_in)
-        : reports(reports_in) {}
+    raw_report_list(const flat_set<ReportID> &reports_in,
+                    const ReportManager &rm, bool do_remap) {
+        if (do_remap) {
+            for (auto &id : reports_in) {
+                reports.insert(rm.getProgramOffset(id));
+            }
+        } else {
+            reports = reports_in;
+        }
+    }
 
     bool operator<(const raw_report_list &b) const {
         return reports < b.reports;
@@ -520,6 +389,8 @@ unique_ptr<raw_report_info> mcclellan_build_strat::gatherReports(
                                                   ReportID *arbReport) const {
     DEBUG_PRINTF("gathering reports\n");
 
+    const bool remap_reports = has_managed_reports(rdfa.kind);
+
     auto ri = ue2::make_unique<raw_report_info_impl>();
     map<raw_report_list, u32> rev;
 
@@ -529,7 +400,7 @@ unique_ptr<raw_report_info> mcclellan_build_strat::gatherReports(
             continue;
         }
 
-        raw_report_list rrl(s.reports);
+        raw_report_list rrl(s.reports, rm, remap_reports);
         DEBUG_PRINTF("non empty r\n");
         if (rev.find(rrl) != rev.end()) {
             reports.push_back(rev[rrl]);
@@ -548,7 +419,7 @@ unique_ptr<raw_report_info> mcclellan_build_strat::gatherReports(
         }
 
         DEBUG_PRINTF("non empty r eod\n");
-        raw_report_list rrl(s.reports_eod);
+        raw_report_list rrl(s.reports_eod, rm, remap_reports);
         if (rev.find(rrl) != rev.end()) {
             reports_eod.push_back(rev[rrl]);
             continue;
@@ -625,6 +496,14 @@ void raw_report_info_impl::fillReportLists(NFA *n, size_t base_offset,
     }
 }
 
+static
+void fillAccelOut(const map<dstate_id_t, AccelScheme> &accel_escape_info,
+                  set<dstate_id_t> *accel_states) {
+    for (dstate_id_t i : accel_escape_info | map_keys) {
+        accel_states->insert(i);
+    }
+}
+
 static
 size_t calcShermanRegionSize(const dfa_info &info) {
     size_t rv = 0;
@@ -692,14 +571,14 @@ int allocateFSN16(dfa_info &info, dstate_id_t *sherman_base) {
 
 static
 aligned_unique_ptr<NFA> mcclellanCompile16(dfa_info &info,
-                                           const CompileContext &cc) {
+                                           const CompileContext &cc,
+                                           set<dstate_id_t> *accel_states) {
     DEBUG_PRINTF("building mcclellan 16\n");
 
     vector<u32> reports; /* index in ri for the appropriate report list */
     vector<u32> reports_eod; /* as above */
     ReportID arb;
     u8 single;
-    u32 accelCount;
 
     u8 alphaShift = info.getAlphaShift();
     assert(alphaShift <= 8);
@@ -711,9 +590,9 @@ aligned_unique_ptr<NFA> mcclellanCompile16(dfa_info &info,
         return nullptr;
     }
 
-    unique_ptr<raw_report_info> ri
-        = info.strat.gatherReports(reports, reports_eod, &single, &arb);
-    populateAccelerationInfo(info, &accelCount, cc.grey);
+    auto ri = info.strat.gatherReports(reports, reports_eod, &single, &arb);
+    map<dstate_id_t, AccelScheme> accel_escape_info
+        = populateAccelerationInfo(info.raw, info.strat, cc.grey);
 
     size_t tran_size = (1 << info.getAlphaShift())
         * sizeof(u16) * count_real_states;
@@ -721,7 +600,7 @@ aligned_unique_ptr<NFA> mcclellanCompile16(dfa_info &info,
     size_t aux_size = sizeof(mstate_aux) * info.size();
 
     size_t aux_offset = ROUNDUP_16(sizeof(NFA) + sizeof(mcclellan) + tran_size);
-    size_t accel_size = info.strat.accelSize() * accelCount;
+    size_t accel_size = info.strat.accelSize() * accel_escape_info.size();
     size_t accel_offset = ROUNDUP_N(aux_offset + aux_size
                                     + ri->getReportListSize(), 32);
     size_t sherman_offset = ROUNDUP_16(accel_offset + accel_size);
@@ -736,7 +615,7 @@ aligned_unique_ptr<NFA> mcclellanCompile16(dfa_info &info,
     char *nfa_base = (char *)nfa.get();
 
     populateBasicInfo(sizeof(u16), info, total_size, aux_offset, accel_offset,
-                      accelCount, arb, single, nfa.get());
+                      accel_escape_info.size(), arb, single, nfa.get());
 
     vector<u32> reportOffsets;
 
@@ -769,12 +648,12 @@ aligned_unique_ptr<NFA> mcclellanCompile16(dfa_info &info,
 
         fillInAux(&aux[fs], i, info, reports, reports_eod, reportOffsets);
 
-        if (info.is_accel(i)) {
+        if (contains(accel_escape_info, i)) {
             this_aux->accel_offset = accel_offset;
             accel_offset += info.strat.accelSize();
             assert(accel_offset + sizeof(NFA) <= sherman_offset);
             assert(ISALIGNED_N(accel_offset, alignof(union AccelAux)));
-            info.strat.buildAccel(i,
+            info.strat.buildAccel(i, accel_escape_info.at(i),
                                   (void *)((char *)m + this_aux->accel_offset));
         }
     }
@@ -798,12 +677,12 @@ aligned_unique_ptr<NFA> mcclellanCompile16(dfa_info &info,
 
         fillInAux(this_aux, i, info, reports, reports_eod, reportOffsets);
 
-        if (info.is_accel(i)) {
+        if (contains(accel_escape_info, i)) {
             this_aux->accel_offset = accel_offset;
             accel_offset += info.strat.accelSize();
             assert(accel_offset + sizeof(NFA) <= sherman_offset);
             assert(ISALIGNED_N(accel_offset, alignof(union AccelAux)));
-            info.strat.buildAccel(i,
+            info.strat.buildAccel(i, accel_escape_info.at(i),
                                   (void *)((char *)m + this_aux->accel_offset));
         }
 
@@ -836,6 +715,10 @@ aligned_unique_ptr<NFA> mcclellanCompile16(dfa_info &info,
 
     markEdges(nfa.get(), succ_table, info);
 
+    if (accel_states && nfa) {
+        fillAccelOut(accel_escape_info, accel_states);
+    }
+
     return nfa;
 }
 
@@ -874,7 +757,9 @@ void fillInBasicState8(const dfa_info &info, mstate_aux *aux, u8 *succ_table,
 }
 
 static
-void allocateFSN8(dfa_info &info, u16 *accel_limit, u16 *accept_limit) {
+void allocateFSN8(dfa_info &info,
+                  const map<dstate_id_t, AccelScheme> &accel_escape_info,
+                  u16 *accel_limit, u16 *accept_limit) {
     info.states[0].impl_id = 0; /* dead is always 0 */
 
     vector<dstate_id_t> norm;
@@ -886,7 +771,7 @@ void allocateFSN8(dfa_info &info, u16 *accel_limit, u16 *accept_limit) {
     for (u32 i = 1; i < info.size(); i++) {
         if (!info.states[i].reports.empty()) {
             accept.push_back(i);
-        } else if (info.is_accel(i)) {
+        } else if (contains(accel_escape_info, i)) {
             accel.push_back(i);
         } else {
             norm.push_back(i);
@@ -915,23 +800,23 @@ void allocateFSN8(dfa_info &info, u16 *accel_limit, u16 *accept_limit) {
 
 static
 aligned_unique_ptr<NFA> mcclellanCompile8(dfa_info &info,
-                                          const CompileContext &cc) {
+                                          const CompileContext &cc,
+                                          set<dstate_id_t> *accel_states) {
     DEBUG_PRINTF("building mcclellan 8\n");
 
     vector<u32> reports;
     vector<u32> reports_eod;
     ReportID arb;
     u8 single;
-    u32 accelCount;
 
-    unique_ptr<raw_report_info> ri
-        = info.strat.gatherReports(reports, reports_eod, &single, &arb);
-    populateAccelerationInfo(info, &accelCount, cc.grey);
+    auto ri = info.strat.gatherReports(reports, reports_eod, &single, &arb);
+    map<dstate_id_t, AccelScheme> accel_escape_info
+        = populateAccelerationInfo(info.raw, info.strat, cc.grey);
 
     size_t tran_size = sizeof(u8) * (1 << info.getAlphaShift()) * info.size();
     size_t aux_size = sizeof(mstate_aux) * info.size();
     size_t aux_offset = ROUNDUP_16(sizeof(NFA) + sizeof(mcclellan) + tran_size);
-    size_t accel_size = info.strat.accelSize() * accelCount;
+    size_t accel_size = info.strat.accelSize() * accel_escape_info.size();
     size_t accel_offset = ROUNDUP_N(aux_offset + aux_size
                                      + ri->getReportListSize(), 32);
     size_t total_size = accel_offset + accel_size;
@@ -951,9 +836,9 @@ aligned_unique_ptr<NFA> mcclellanCompile8(dfa_info &info,
 
     mcclellan *m = (mcclellan *)getMutableImplNfa(nfa.get());
 
-    allocateFSN8(info, &m->accel_limit_8, &m->accept_limit_8);
+    allocateFSN8(info, accel_escape_info, &m->accel_limit_8, &m->accept_limit_8);
     populateBasicInfo(sizeof(u8), info, total_size, aux_offset, accel_offset,
-                      accelCount, arb, single, nfa.get());
+                      accel_escape_info.size(), arb, single, nfa.get());
 
     vector<u32> reportOffsets;
 
@@ -964,13 +849,14 @@ aligned_unique_ptr<NFA> mcclellanCompile8(dfa_info &info,
     mstate_aux *aux = (mstate_aux *)(nfa_base + aux_offset);
 
     for (size_t i = 0; i < info.size(); i++) {
-        if (info.is_accel(i)) {
+        if (contains(accel_escape_info, i)) {
             u32 j = info.implId(i);
 
             aux[j].accel_offset = accel_offset;
             accel_offset += info.strat.accelSize();
 
-            info.strat.buildAccel(i, (void *)((char *)m + aux[j].accel_offset));
+            info.strat.buildAccel(i, accel_escape_info.at(i),
+                                  (void *)((char *)m + aux[j].accel_offset));
         }
 
         fillInBasicState8(info, aux, succ_table, reportOffsets, reports,
@@ -981,6 +867,10 @@ aligned_unique_ptr<NFA> mcclellanCompile8(dfa_info &info,
 
     DEBUG_PRINTF("rl size %zu\n", ri->size());
 
+    if (accel_states && nfa) {
+        fillAccelOut(accel_escape_info, accel_states);
+    }
+
     return nfa;
 }
 
@@ -1163,15 +1053,6 @@ bool is_cyclic_near(const raw_dfa &raw, dstate_id_t root) {
     return false;
 }
 
-static
-void fillAccelOut(const dfa_info &info, set<dstate_id_t> *accel_states) {
-    for (size_t i = 0; i < info.size(); i++) {
-        if (info.is_accel(i)) {
-            accel_states->insert(i);
-        }
-    }
-}
-
 aligned_unique_ptr<NFA> mcclellanCompile_i(raw_dfa &raw, dfa_build_strat &strat,
                                            const CompileContext &cc,
                                            set<dstate_id_t> *accel_states) {
@@ -1200,26 +1081,23 @@ aligned_unique_ptr<NFA> mcclellanCompile_i(raw_dfa &raw, dfa_build_strat &strat,
 
     aligned_unique_ptr<NFA> nfa;
     if (!using8bit) {
-        nfa = mcclellanCompile16(info, cc);
+        nfa = mcclellanCompile16(info, cc, accel_states);
     } else {
-        nfa = mcclellanCompile8(info, cc);
+        nfa = mcclellanCompile8(info, cc, accel_states);
     }
 
     if (has_eod_reports) {
         nfa->flags |= NFA_ACCEPTS_EOD;
     }
 
-    if (accel_states && nfa) {
-        fillAccelOut(info, accel_states);
-    }
-
     DEBUG_PRINTF("compile done\n");
     return nfa;
 }
 
 aligned_unique_ptr<NFA> mcclellanCompile(raw_dfa &raw, const CompileContext &cc,
+                                         const ReportManager &rm,
                                          set<dstate_id_t> *accel_states) {
-    mcclellan_build_strat mbs(raw);
+    mcclellan_build_strat mbs(raw, rm);
     return mcclellanCompile_i(raw, mbs, cc, accel_states);
 }
 
diff --git a/src/nfa/mcclellancompile.h b/src/nfa/mcclellancompile.h
index 78126bc8..ba519cac 100644
--- a/src/nfa/mcclellancompile.h
+++ b/src/nfa/mcclellancompile.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -31,6 +31,7 @@
 
 #include "rdfa.h"
 #include "ue2common.h"
+#include "util/accel_scheme.h"
 #include "util/alloc.h"
 #include "util/charreach.h"
 #include "util/ue2_containers.h"
@@ -43,6 +44,7 @@ struct NFA;
 
 namespace ue2 {
 
+class ReportManager;
 struct CompileContext;
 
 struct raw_report_info {
@@ -54,15 +56,9 @@ struct raw_report_info {
                                  std::vector<u32> &ro /* out */) const = 0;
 };
 
-struct escape_info {
-    CharReach outs;
-    CharReach outs2_single;
-    flat_set<std::pair<u8, u8>> outs2;
-    bool outs2_broken = false;
-};
-
 class dfa_build_strat {
 public:
+    explicit dfa_build_strat(const ReportManager &rm_in) : rm(rm_in) {}
     virtual ~dfa_build_strat();
     virtual raw_dfa &get_raw() const = 0;
     virtual std::unique_ptr<raw_report_info> gatherReports(
@@ -70,25 +66,29 @@ public:
                                std::vector<u32> &reports_eod /* out */,
                                u8 *isSingleReport /* out */,
                                ReportID *arbReport  /* out */) const = 0;
-    virtual void find_escape_strings(dstate_id_t this_idx,
-                                     escape_info *out) const = 0;
+    virtual AccelScheme find_escape_strings(dstate_id_t this_idx) const = 0;
     virtual size_t accelSize(void) const = 0;
-    virtual void buildAccel(dstate_id_t this_idx, void *accel_out) = 0;
+    virtual void buildAccel(dstate_id_t this_idx, const AccelScheme &info,
+                            void *accel_out) = 0;
+protected:
+    const ReportManager &rm;
 };
 
 class mcclellan_build_strat : public dfa_build_strat {
 public:
-    explicit mcclellan_build_strat(raw_dfa &r) : rdfa(r) {}
+    mcclellan_build_strat(raw_dfa &rdfa_in, const ReportManager &rm_in)
+        : dfa_build_strat(rm_in), rdfa(rdfa_in) {}
     raw_dfa &get_raw() const override { return rdfa; }
     std::unique_ptr<raw_report_info> gatherReports(
-                                   std::vector<u32> &reports /* out */,
-                                   std::vector<u32> &reports_eod /* out */,
-                                   u8 *isSingleReport /* out */,
-                                   ReportID *arbReport  /* out */) const override;
-    void find_escape_strings(dstate_id_t this_idx,
-                             escape_info *out) const override;
+                                  std::vector<u32> &reports /* out */,
+                                  std::vector<u32> &reports_eod /* out */,
+                                  u8 *isSingleReport /* out */,
+                                  ReportID *arbReport  /* out */) const override;
+    AccelScheme find_escape_strings(dstate_id_t this_idx) const override;
     size_t accelSize(void) const override;
-    void buildAccel(dstate_id_t this_idx, void *accel_out) override;
+    void buildAccel(dstate_id_t this_idx,const AccelScheme &info,
+                    void *accel_out) override;
+    virtual u32 max_allowed_offset_accel() const;
 
 private:
     raw_dfa &rdfa;
@@ -98,6 +98,7 @@ private:
  * states */
 ue2::aligned_unique_ptr<NFA>
 mcclellanCompile(raw_dfa &raw, const CompileContext &cc,
+                 const ReportManager &rm,
                  std::set<dstate_id_t> *accel_states = nullptr);
 
 /* used internally by mcclellan/haig/gough compile process */
diff --git a/src/nfa/mcclellancompile_accel.cpp b/src/nfa/mcclellancompile_accel.cpp
new file mode 100644
index 00000000..c5325fcc
--- /dev/null
+++ b/src/nfa/mcclellancompile_accel.cpp
@@ -0,0 +1,422 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "mcclellancompile_accel.h"
+
+#include "mcclellancompile_util.h"
+
+#include "grey.h"
+#include "nfagraph/ng_limex_accel.h"
+#include "util/charreach.h"
+#include "util/container.h"
+#include "util/dump_charclass.h"
+
+#include <vector>
+#include <sstream>
+
+#define PATHS_LIMIT 500
+
+using namespace std;
+
+namespace ue2 {
+
+namespace {
+
+struct path {
+    vector<CharReach> reach;
+    dstate_id_t dest = DEAD_STATE;
+    explicit path(dstate_id_t base) : dest(base) {}
+};
+
+}
+
+static UNUSED
+string describeClasses(const vector<CharReach> &v) {
+    std::ostringstream oss;
+    for (const auto &cr : v) {
+        describeClass(oss, cr);
+    }
+    return oss.str();
+}
+
+static
+void dump_paths(const vector<path> &paths) {
+    for (UNUSED const auto &p : paths) {
+        DEBUG_PRINTF("[%s] -> %u\n", describeClasses(p.reach).c_str(), p.dest);
+    }
+    DEBUG_PRINTF("%zu paths\n", paths.size());
+}
+
+static
+bool is_useful_path(const vector<path> &good, const path &p) {
+    for (const auto &g : good) {
+        assert(g.dest == p.dest);
+        assert(g.reach.size() <= p.reach.size());
+        auto git = g.reach.rbegin();
+        auto pit = p.reach.rbegin();
+
+        for (; git != g.reach.rend(); ++git, ++pit) {
+            if (!pit->isSubsetOf(*git)) {
+                goto next;
+            }
+        }
+        DEBUG_PRINTF("better: [%s] -> %u\n",
+                     describeClasses(g.reach).c_str(), g.dest);
+
+        return false;
+    next:;
+    }
+
+    return true;
+}
+
+static
+path append(const path &orig, const CharReach &cr, u32 new_dest) {
+    path p(new_dest);
+    p.reach = orig.reach;
+    p.reach.push_back(cr);
+
+    return p;
+}
+
+static
+void extend(const raw_dfa &rdfa, const path &p,
+            map<u32, vector<path> > &all,
+            vector<path> &out) {
+    dstate s = rdfa.states[p.dest];
+
+    if (!p.reach.empty() && p.reach.back().none()) {
+        out.push_back(p);
+        return;
+    }
+
+    if (!s.reports.empty()) {
+        if (generates_callbacks(rdfa.kind)) {
+            out.push_back(p);
+            return;
+        } else {
+            path pp = append(p, CharReach(), p.dest);
+            all[p.dest].push_back(pp);
+            out.push_back(pp);
+        }
+    }
+
+    if (!s.reports_eod.empty()) {
+        path pp = append(p, CharReach(), p.dest);
+        all[p.dest].push_back(pp);
+        out.push_back(pp);
+    }
+
+    map<u32, CharReach> dest;
+    for (unsigned i = 0; i < N_CHARS; i++) {
+        u32 succ = s.next[rdfa.alpha_remap[i]];
+        dest[succ].set(i);
+    }
+
+    for (const auto &e : dest) {
+        path pp = append(p, e.second, e.first);
+        if (!is_useful_path(all[e.first], pp)) {
+            DEBUG_PRINTF("not useful: [%s] -> %u\n",
+                         describeClasses(pp.reach).c_str(), pp.dest);
+            continue;
+        }
+
+        DEBUG_PRINTF("----good: [%s] -> %u\n",
+                         describeClasses(pp.reach).c_str(), pp.dest);
+        all[e.first].push_back(pp);
+        out.push_back(pp);
+    }
+}
+
+static
+vector<vector<CharReach> > generate_paths(const raw_dfa &rdfa, dstate_id_t base,
+                                          u32 len) {
+    vector<path> paths{ path(base) };
+    map<u32, vector<path> > all;
+    all[base].push_back(path(base));
+    for (u32 i = 0; i < len && paths.size() < PATHS_LIMIT; i++) {
+        vector<path> next_gen;
+        for (const auto &p : paths) {
+            extend(rdfa, p, all, next_gen);
+        }
+
+        paths = move(next_gen);
+    }
+
+    dump_paths(paths);
+
+    vector<vector<CharReach> > rv;
+    for (auto &p : paths) {
+        rv.push_back(move(p.reach));
+    }
+    return rv;
+}
+
+static
+AccelScheme look_for_offset_accel(const raw_dfa &rdfa, dstate_id_t base,
+                                  u32 max_allowed_accel_offset) {
+    DEBUG_PRINTF("looking for accel for %hu\n", base);
+    vector<vector<CharReach> > paths = generate_paths(rdfa, base,
+                                                   max_allowed_accel_offset + 1);
+    AccelScheme as = findBestAccelScheme(paths, CharReach(), true);
+    DEBUG_PRINTF("found %s + %u\n", describeClass(as.cr).c_str(), as.offset);
+    return as;
+}
+
+static
+vector<u16> find_nonexit_symbols(const raw_dfa &rdfa,
+                                 const CharReach &escape) {
+    set<u16> rv;
+    CharReach nonexit = ~escape;
+    for (auto i = nonexit.find_first(); i != CharReach::npos;
+         i = nonexit.find_next(i)) {
+        rv.insert(rdfa.alpha_remap[i]);
+    }
+
+    return vector<u16>(rv.begin(), rv.end());
+}
+
+static
+set<dstate_id_t> find_region(const raw_dfa &rdfa, dstate_id_t base,
+                             const AccelScheme &ei) {
+    DEBUG_PRINTF("looking for region around %hu\n", base);
+
+    set<dstate_id_t> region = {base};
+
+    if (!ei.double_byte.empty()) {
+        return region;
+    }
+
+    DEBUG_PRINTF("accel %s+%u\n", describeClass(ei.cr).c_str(), ei.offset);
+
+    const CharReach &escape = ei.cr;
+    auto nonexit_symbols = find_nonexit_symbols(rdfa, escape);
+
+    vector<dstate_id_t> pending = {base};
+    while (!pending.empty()) {
+        dstate_id_t curr = pending.back();
+        pending.pop_back();
+        for (auto s : nonexit_symbols) {
+            dstate_id_t t = rdfa.states[curr].next[s];
+            if (contains(region, t)) {
+                continue;
+            }
+
+            DEBUG_PRINTF("    %hu is in region\n", t);
+            region.insert(t);
+            pending.push_back(t);
+        }
+    }
+
+    return region;
+}
+
+static
+bool better(const AccelScheme &a, const AccelScheme &b) {
+    if (!a.double_byte.empty() && b.double_byte.empty()) {
+        return true;
+    }
+
+    if (!b.double_byte.empty()) {
+        return false;
+    }
+
+    return a.cr.count() < b.cr.count();
+}
+
+static
+vector<CharReach> reverse_alpha_remapping(const raw_dfa &rdfa) {
+    vector<CharReach> rv(rdfa.alpha_size - 1); /* TOP not required */
+
+    for (u32 i = 0; i < N_CHARS; i++) {
+        rv.at(rdfa.alpha_remap[i]).set(i);
+    }
+
+    return rv;
+}
+
+map<dstate_id_t, AccelScheme> populateAccelerationInfo(const raw_dfa &rdfa,
+                                                   const dfa_build_strat &strat,
+                                                   const Grey &grey) {
+    map<dstate_id_t, AccelScheme> rv;
+    if (!grey.accelerateDFA) {
+        return rv;
+    }
+
+    dstate_id_t sds_proxy = get_sds_or_proxy(rdfa);
+    DEBUG_PRINTF("sds %hu\n", sds_proxy);
+
+    for (size_t i = 0; i < rdfa.states.size(); i++) {
+        if (i == DEAD_STATE) {
+            continue;
+        }
+
+        /* Note on report acceleration states: While we can't accelerate while we
+         * are spamming out callbacks, the QR code paths don't raise reports
+         * during scanning so they can accelerate report states. */
+        if (generates_callbacks(rdfa.kind) && !rdfa.states[i].reports.empty()) {
+            continue;
+        }
+
+        size_t single_limit = i == sds_proxy ? ACCEL_DFA_MAX_FLOATING_STOP_CHAR
+                                             : ACCEL_DFA_MAX_STOP_CHAR;
+        DEBUG_PRINTF("inspecting %zu/%hu: %zu\n", i, sds_proxy, single_limit);
+
+        AccelScheme ei = strat.find_escape_strings(i);
+        if (ei.cr.count() > single_limit) {
+            DEBUG_PRINTF("state %zu is not accelerable has %zu\n", i,
+                         ei.cr.count());
+            continue;
+        }
+
+        DEBUG_PRINTF("state %zu should be accelerable %zu\n",
+                     i, ei.cr.count());
+
+        rv[i] = ei;
+    }
+
+    /* provide accleration states to states in the region of sds */
+    if (contains(rv, sds_proxy)) {
+        AccelScheme sds_ei = rv[sds_proxy];
+        sds_ei.double_byte.clear(); /* region based on single byte scheme
+                                     * may differ from double byte */
+        DEBUG_PRINTF("looking to expand offset accel to nearby states, %zu\n",
+                     sds_ei.cr.count());
+        auto sds_region = find_region(rdfa, sds_proxy, sds_ei);
+        for (auto s : sds_region) {
+            if (!contains(rv, s) || better(sds_ei, rv[s])) {
+                rv[s] = sds_ei;
+            }
+        }
+    }
+
+    return rv;
+}
+
+static
+bool double_byte_ok(const AccelScheme &info) {
+    return !info.double_byte.empty()
+        && info.double_cr.count() < info.double_byte.size()
+        && info.double_cr.count() <= 2 && !info.double_byte.empty();
+}
+
+AccelScheme find_mcclellan_escape_info(const raw_dfa &rdfa, dstate_id_t this_idx,
+                                       u32 max_allowed_accel_offset) {
+    AccelScheme rv;
+    rv.cr.clear();
+    rv.offset = 0;
+    const dstate &raw = rdfa.states[this_idx];
+    const vector<CharReach> rev_map = reverse_alpha_remapping(rdfa);
+    bool outs2_broken = false;
+    map<dstate_id_t, CharReach> succs;
+
+    for (u32 i = 0; i < rev_map.size(); i++) {
+        if (raw.next[i] == this_idx) {
+            continue;
+        }
+
+        const CharReach &cr_i = rev_map.at(i);
+
+        rv.cr |= cr_i;
+        dstate_id_t next_id = raw.next[i];
+
+        DEBUG_PRINTF("next is %hu\n", next_id);
+        const dstate &raw_next = rdfa.states[next_id];
+
+        if (outs2_broken) {
+            continue;
+        }
+
+        if (!raw_next.reports.empty() && generates_callbacks(rdfa.kind)) {
+            DEBUG_PRINTF("leads to report\n");
+            outs2_broken = true;  /* cannot accelerate over reports */
+            continue;
+        }
+        succs[next_id] |= cr_i;
+    }
+
+    if (!outs2_broken) {
+        for (const auto &e : succs) {
+            const CharReach &cr_i = e.second;
+            const dstate &raw_next = rdfa.states[e.first];
+
+            CharReach cr_all_j;
+            for (u32 j = 0; j < rev_map.size(); j++) {
+                if (raw_next.next[j] == raw.next[j]) {
+                    continue;
+                }
+
+                DEBUG_PRINTF("state %hu: adding sym %u -> %hu to 2 \n", e.first,
+                             j, raw_next.next[j]);
+                cr_all_j |= rev_map.at(j);
+            }
+
+            if (cr_i.count() * cr_all_j.count() > 8) {
+                DEBUG_PRINTF("adding %zu to double_cr\n", cr_i.count());
+                rv.double_cr |= cr_i;
+            } else {
+                for (auto ii = cr_i.find_first(); ii != CharReach::npos;
+                     ii = cr_i.find_next(ii)) {
+                    for (auto jj = cr_all_j.find_first(); jj != CharReach::npos;
+                         jj = cr_all_j.find_next(jj)) {
+                        rv.double_byte.emplace((u8)ii, (u8)jj);
+                    }
+                }
+            }
+        }
+
+        if (rv.double_byte.size() > 8) {
+            DEBUG_PRINTF("outs2 too big\n");
+            outs2_broken = true;
+        }
+
+        if (outs2_broken) {
+            rv.double_byte.clear();
+        }
+    }
+
+    DEBUG_PRINTF("this %u, sds proxy %hu\n", this_idx, get_sds_or_proxy(rdfa));
+    DEBUG_PRINTF("broken %d\n", outs2_broken);
+    if (!double_byte_ok(rv) && !is_triggered(rdfa.kind)
+        && this_idx == rdfa.start_floating
+        && this_idx != DEAD_STATE) {
+        DEBUG_PRINTF("looking for offset accel at %u\n", this_idx);
+        auto offset = look_for_offset_accel(rdfa, this_idx,
+                                            max_allowed_accel_offset);
+        DEBUG_PRINTF("width %zu vs %zu\n", offset.cr.count(),
+                      rv.cr.count());
+        if (double_byte_ok(offset) || offset.cr.count() < rv.cr.count()) {
+            DEBUG_PRINTF("using offset accel\n");
+            rv = offset;
+        }
+    }
+
+    return rv;
+}
+
+}
diff --git a/src/nfa/mcclellancompile_accel.h b/src/nfa/mcclellancompile_accel.h
new file mode 100644
index 00000000..427267d7
--- /dev/null
+++ b/src/nfa/mcclellancompile_accel.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MCCLELLANCOMPILE_ACCEL_H
+#define MCCLELLANCOMPILE_ACCEL_H
+
+#include "mcclellancompile.h"
+
+#include <map>
+
+namespace ue2 {
+
+struct Grey;
+
+#define ACCEL_DFA_MAX_OFFSET_DEPTH 4
+
+/** Maximum tolerated number of escape character from an accel state.
+ * This is larger than nfa, as we don't have a budget and the nfa cheats on stop
+ * characters for sets of states */
+#define ACCEL_DFA_MAX_STOP_CHAR 160
+
+/** Maximum tolerated number of escape character from a sds accel state. Larger
+ * than normal states as accelerating sds is important. Matches NFA value */
+#define ACCEL_DFA_MAX_FLOATING_STOP_CHAR 192
+
+std::map<dstate_id_t, AccelScheme> populateAccelerationInfo(const raw_dfa &rdfa,
+                                                   const dfa_build_strat &strat,
+                                                   const Grey &grey);
+
+AccelScheme find_mcclellan_escape_info(const raw_dfa &rdfa,
+                                       dstate_id_t this_idx,
+                                       u32 max_allowed_accel_offset);
+
+}
+
+#endif
diff --git a/src/nfa/mcclellancompile_util.cpp b/src/nfa/mcclellancompile_util.cpp
index cd85ef36..234574d8 100644
--- a/src/nfa/mcclellancompile_util.cpp
+++ b/src/nfa/mcclellancompile_util.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -228,13 +228,13 @@ void calc_min_dist_to_accept(const raw_dfa &raw,
     }
 }
 
-void prune_overlong(raw_dfa &raw, u32 max_offset) {
+bool prune_overlong(raw_dfa &raw, u32 max_offset) {
     DEBUG_PRINTF("pruning to at most %u\n", max_offset);
     vector<u32> bob_dist;
     u32 max_min_dist_bob = calc_min_dist_from_bob(raw, &bob_dist);
 
     if (max_min_dist_bob <= max_offset) {
-        return;
+        return false;
     }
 
     vector<vector<dstate_id_t> > in_edges;
@@ -282,6 +282,8 @@ void prune_overlong(raw_dfa &raw, u32 max_offset) {
     /* update specials */
     raw.start_floating = new_ids[raw.start_floating];
     raw.start_anchored = new_ids[raw.start_anchored];
+
+    return true;
 }
 
 set<ReportID> all_reports(const raw_dfa &rdfa) {
@@ -334,4 +336,63 @@ size_t hash_dfa(const raw_dfa &rdfa) {
     return v;
 }
 
+static
+bool has_self_loop(dstate_id_t s, const raw_dfa &raw) {
+    u16 top_remap = raw.alpha_remap[TOP];
+    for (u32 i = 0; i < raw.states[s].next.size(); i++) {
+        if (i != top_remap && raw.states[s].next[i] == s) {
+            return true;
+        }
+    }
+    return false;
+}
+
+dstate_id_t get_sds_or_proxy(const raw_dfa &raw) {
+    if (raw.start_floating != DEAD_STATE) {
+        DEBUG_PRINTF("has floating start\n");
+        return raw.start_floating;
+    }
+
+    DEBUG_PRINTF("looking for SDS proxy\n");
+
+    dstate_id_t s = raw.start_anchored;
+
+    if (has_self_loop(s, raw)) {
+        return s;
+    }
+
+    u16 top_remap = raw.alpha_remap[TOP];
+
+    ue2::unordered_set<dstate_id_t> seen;
+    while (true) {
+        seen.insert(s);
+        DEBUG_PRINTF("basis %hu\n", s);
+
+        /* check if we are connected to a state with a self loop */
+        for (u32 i = 0; i < raw.states[s].next.size(); i++) {
+            dstate_id_t t = raw.states[s].next[i];
+            if (i != top_remap && t != DEAD_STATE && has_self_loop(t, raw)) {
+                return t;
+            }
+        }
+
+        /* find a neighbour to use as a basis for looking for the sds proxy */
+        dstate_id_t t = DEAD_STATE;
+        for (u32 i = 0; i < raw.states[s].next.size(); i++) {
+            dstate_id_t tt = raw.states[s].next[i];
+            if (i != top_remap && tt != DEAD_STATE && !contains(seen, tt)) {
+                t = tt;
+                break;
+            }
+        }
+
+        if (t == DEAD_STATE) {
+            /* we were unable to find a state to use as a SDS proxy */
+            return DEAD_STATE;
+        }
+
+        s = t;
+    }
+}
+
 } // namespace ue2
diff --git a/src/nfa/mcclellancompile_util.h b/src/nfa/mcclellancompile_util.h
index 183abcaa..7b6c033a 100644
--- a/src/nfa/mcclellancompile_util.h
+++ b/src/nfa/mcclellancompile_util.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -29,16 +29,21 @@
 #ifndef MCCLELLAN_COMPILE_UTIL_H
 #define MCCLELLAN_COMPILE_UTIL_H
 
+#include "rdfa.h"
 #include "ue2common.h"
 
 #include <set>
 
 namespace ue2 {
 
-struct raw_dfa;
-
 u32 remove_leading_dots(raw_dfa &raw);
-void prune_overlong(raw_dfa &raw, u32 max_offset);
+
+/**
+ * Prunes any states which cannot be reached within max_offset from start of
+ * stream. Returns false if no changes are made to the rdfa
+ */
+bool prune_overlong(raw_dfa &raw, u32 max_offset);
+
 std::set<ReportID> all_reports(const raw_dfa &rdfa);
 bool has_eod_accepts(const raw_dfa &rdfa);
 bool has_non_eod_accepts(const raw_dfa &rdfa);
@@ -50,6 +55,8 @@ size_t hash_dfa_no_reports(const raw_dfa &rdfa);
 /** \brief Compute a simple hash of this raw_dfa, including its reports. */
 size_t hash_dfa(const raw_dfa &rdfa);
 
+dstate_id_t get_sds_or_proxy(const raw_dfa &raw);
+
 } // namespace ue2
 
 #endif
diff --git a/src/nfa/mpv.c b/src/nfa/mpv.c
index 5f4910a6..4bae7b18 100644
--- a/src/nfa/mpv.c
+++ b/src/nfa/mpv.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -124,7 +124,7 @@ char processReports(const struct mpv *m, u8 *reporters,
                 DEBUG_PRINTF("report %u at %llu\n", curr->report,
                               report_offset);
 
-                if (curr->unbounded) {
+                if (curr->unbounded && !curr->simple_exhaust) {
                     assert(rl_count < m->puffette_count);
                     *rl = curr->report;
                     ++rl;
@@ -176,7 +176,9 @@ char processReportsForRange(const struct mpv *m, u8 *reporters,
         return MO_CONTINUE_MATCHING;
     }
 
-    for (u32 i = 2; i <= length; i++) {
+    DEBUG_PRINTF("length=%zu, rl_count=%u\n", length, rl_count);
+
+    for (size_t i = 2; i <= length; i++) {
         for (u32 j = 0; j < rl_count; j++) {
             if (cb(first_offset + i, rl[j], ctxt) == MO_HALT_MATCHING) {
                 DEBUG_PRINTF("bailing\n");
diff --git a/src/nfa/mpv_dump.cpp b/src/nfa/mpv_dump.cpp
index e731df87..504cc677 100644
--- a/src/nfa/mpv_dump.cpp
+++ b/src/nfa/mpv_dump.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -108,6 +108,9 @@ void dumpKilo(FILE *f, const mpv *m, const mpv_kilopuff *k) {
         fprintf(f, "    Puffette %u\n", i);
         fprintf(f, "        repeats:   %u%s\n", p[i].repeats,
                 p[i].unbounded ? "," : "");
+        if (p[i].simple_exhaust) {
+            fprintf(f, "        simple exhaustible\n");
+        }
         fprintf(f, "        report id: %u\n", p[i].report);
     }
 
diff --git a/src/nfa/mpv_internal.h b/src/nfa/mpv_internal.h
index 7a1a2273..a52853dc 100644
--- a/src/nfa/mpv_internal.h
+++ b/src/nfa/mpv_internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -40,6 +40,15 @@
 struct mpv_puffette {
     u32 repeats;
     char unbounded;
+
+    /**
+     * \brief Report is simple-exhaustible.
+     *
+     * If this is true, we do best-effort suppression of runs of reports, only
+     * delivering the first one.
+     */
+    char simple_exhaust;
+
     ReportID report;
 };
 
diff --git a/src/nfa/mpvcompile.cpp b/src/nfa/mpvcompile.cpp
index e4741ef1..b024b530 100644
--- a/src/nfa/mpvcompile.cpp
+++ b/src/nfa/mpvcompile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -36,6 +36,7 @@
 #include "util/alloc.h"
 #include "util/multibit_internal.h"
 #include "util/order_check.h"
+#include "util/report_manager.h"
 #include "util/verify_types.h"
 
 #include <algorithm>
@@ -53,10 +54,8 @@ namespace ue2 {
 namespace {
 struct pcomp {
     bool operator()(const raw_puff &a, const raw_puff &b) const {
-        ORDER_CHECK(repeats);
-        ORDER_CHECK(unbounded);
-        ORDER_CHECK(report);
-        return false;
+        return tie(a.repeats, a.unbounded, a.simple_exhaust, a.report) <
+               tie(b.repeats, b.unbounded, b.simple_exhaust, b.report);
     }
 };
 
@@ -84,12 +83,21 @@ struct ClusterKey {
 } // namespace
 
 static
-void writePuffette(mpv_puffette *out, const raw_puff &rp) {
+void writePuffette(mpv_puffette *out, const raw_puff &rp,
+                   const ReportManager &rm) {
     DEBUG_PRINTF("outputting %u %d %u to %p\n", rp.repeats, (int)rp.unbounded,
                  rp.report, out);
     out->repeats = rp.repeats;
     out->unbounded = rp.unbounded;
-    out->report = rp.report;
+    out->simple_exhaust = rp.simple_exhaust;
+    out->report = rm.getProgramOffset(rp.report);
+}
+
+static
+void writeSentinel(mpv_puffette *out) {
+    DEBUG_PRINTF("outputting sentinel to %p\n", out);
+    memset(out, 0, sizeof(*out));
+    out->report = INVALID_REPORT;
 }
 
 static
@@ -148,8 +156,8 @@ void populateClusters(const vector<raw_puff> &puffs_in,
 
 static
 void writeKiloPuff(const map<ClusterKey, vector<raw_puff>>::const_iterator &it,
-                   u32 counter_offset, mpv *m, mpv_kilopuff *kp,
-                   mpv_puffette **pa) {
+                   const ReportManager &rm, u32 counter_offset, mpv *m,
+                   mpv_kilopuff *kp, mpv_puffette **pa) {
     const CharReach &reach = it->first.reach;
     const vector<raw_puff> &puffs = it->second;
 
@@ -182,11 +190,11 @@ void writeKiloPuff(const map<ClusterKey, vector<raw_puff>>::const_iterator &it,
     kp->puffette_offset = verify_u32((char *)*pa - (char *)m);
     for (size_t i = 0; i < puffs.size(); i++) {
         assert(!it->first.auto_restart || puffs[i].unbounded);
-        writePuffette(*pa + i, puffs[i]);
+        writePuffette(*pa + i, puffs[i], rm);
     }
 
     *pa += puffs.size();
-    writePuffette(*pa, raw_puff(0U, false, INVALID_REPORT, CharReach()));
+    writeSentinel(*pa);
     ++*pa;
 
     writeDeadPoint(kp, puffs);
@@ -301,7 +309,8 @@ const mpv_counter_info &findCounter(const vector<mpv_counter_info> &counters,
 }
 
 aligned_unique_ptr<NFA> mpvCompile(const vector<raw_puff> &puffs_in,
-                                   const vector<raw_puff> &triggered_puffs) {
+                                   const vector<raw_puff> &triggered_puffs,
+                                   const ReportManager &rm) {
     assert(!puffs_in.empty() || !triggered_puffs.empty());
     u32 puffette_count = puffs_in.size() + triggered_puffs.size();
 
@@ -341,7 +350,7 @@ aligned_unique_ptr<NFA> mpvCompile(const vector<raw_puff> &puffs_in,
          + sizeof(mpv_counter_info) * counters.size());
     mpv_puffette *pa = pa_base;
 
-    writePuffette(pa, raw_puff(0U, false, INVALID_REPORT, CharReach()));
+    writeSentinel(pa);
 
     ++pa; /* skip init sentinel */
 
@@ -367,8 +376,9 @@ aligned_unique_ptr<NFA> mpvCompile(const vector<raw_puff> &puffs_in,
     mpv_kilopuff *kp_begin = (mpv_kilopuff *)(m + 1);
     mpv_kilopuff *kp = kp_begin;
     for (auto it = puff_clusters.begin(); it != puff_clusters.end(); ++it) {
-        writeKiloPuff(it, findCounter(counters, kp - kp_begin).counter_offset,
-                      m, kp, &pa);
+        writeKiloPuff(it, rm,
+                      findCounter(counters, kp - kp_begin).counter_offset, m,
+                      kp, &pa);
         ++kp;
     }
     assert((char *)pa == (char *)nfa.get() + len);
diff --git a/src/nfa/mpvcompile.h b/src/nfa/mpvcompile.h
index 01c0de79..fb91ac64 100644
--- a/src/nfa/mpvcompile.h
+++ b/src/nfa/mpvcompile.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -40,14 +40,19 @@ struct NFA;
 
 namespace ue2 {
 
+class ReportManager;
+
 struct raw_puff {
     raw_puff(u32 repeats_in, bool unbounded_in, ReportID report_in,
-             const CharReach &reach_in, bool auto_restart_in = false)
+             const CharReach &reach_in, bool auto_restart_in = false,
+             bool simple_exhaust_in = false)
         : repeats(repeats_in), unbounded(unbounded_in),
-          auto_restart(auto_restart_in), report(report_in), reach(reach_in) {}
+          auto_restart(auto_restart_in), simple_exhaust(simple_exhaust_in),
+          report(report_in), reach(reach_in) {}
     u32 repeats; /**< report match after this many matching bytes */
     bool unbounded; /**< keep producing matches after repeats are reached */
     bool auto_restart; /**< for /[^X]{n}/ type patterns */
+    bool simple_exhaust; /* first report will exhaust us */
     ReportID report;
     CharReach reach; /**< = ~escapes */
 };
@@ -56,9 +61,9 @@ struct raw_puff {
  * puffs in the triggered_puffs vector are enabled when an TOP_N event is
  * delivered corresponding to their index in the vector
  */
-aligned_unique_ptr<NFA>
-mpvCompile(const std::vector<raw_puff> &puffs,
-           const std::vector<raw_puff> &triggered_puffs);
+aligned_unique_ptr<NFA> mpvCompile(const std::vector<raw_puff> &puffs,
+                                   const std::vector<raw_puff> &triggered_puffs,
+                                   const ReportManager &rm);
 
 } // namespace ue2
 
diff --git a/src/nfa/multiaccel_common.h b/src/nfa/multiaccel_common.h
new file mode 100644
index 00000000..1a13c3b6
--- /dev/null
+++ b/src/nfa/multiaccel_common.h
@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTIACCEL_COMMON_H_
+#define MULTIACCEL_COMMON_H_
+
+#include "config.h"
+#include "ue2common.h"
+#include "util/join.h"
+#include "util/bitutils.h"
+
+/*
+ * When doing shifting, remember that the total number of shifts should be n-1
+ */
+#define VARISHIFT(src, dst, len) \
+    do { \
+        (dst) &= (src) >> (len); \
+    } while (0)
+#define STATIC_SHIFT1(x) \
+    do { \
+        (x) &= (x) >> 1; \
+    } while (0)
+#define STATIC_SHIFT2(x) \
+    do { \
+        (x) &= (x) >> 2;\
+    } while (0)
+#define STATIC_SHIFT4(x) \
+    do { \
+        (x) &= (x) >> 4; \
+    } while (0)
+#define STATIC_SHIFT8(x) \
+    do { \
+        (x) &= (x) >> 8; \
+    } while (0)
+#define SHIFT1(x) \
+    do {} while (0)
+#define SHIFT2(x) \
+    do { \
+        STATIC_SHIFT1(x); \
+    } while (0)
+#define SHIFT3(x) \
+    do { \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT1(x); \
+    } while (0)
+#define SHIFT4(x) \
+    do { \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT2(x); \
+    } while (0)
+#define SHIFT5(x) \
+    do { \
+        SHIFT4(x); \
+        STATIC_SHIFT1(x); \
+    } while (0)
+#define SHIFT6(x) \
+    do { \
+        SHIFT4(x); \
+        STATIC_SHIFT2(x); \
+    } while (0)
+#define SHIFT7(x) \
+    do { \
+        SHIFT4(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT2(x); \
+    } while (0)
+#define SHIFT8(x) \
+    do { \
+        SHIFT4(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT9(x) \
+    do { \
+        SHIFT8(x); \
+        STATIC_SHIFT1(x); \
+    } while (0)
+#define SHIFT10(x) \
+    do { \
+        SHIFT8(x); \
+        STATIC_SHIFT2(x); \
+    } while (0)
+#define SHIFT11(x) \
+    do { \
+        SHIFT8(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT2(x); \
+    } while (0)
+#define SHIFT12(x); \
+    do { \
+        SHIFT8(x);\
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT13(x); \
+    do { \
+        SHIFT8(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT14(x) \
+    do { \
+        SHIFT8(x); \
+        STATIC_SHIFT2(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT15(x) \
+    do { \
+        SHIFT8(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT2(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT16(x) \
+    do { \
+        SHIFT8(x); \
+        STATIC_SHIFT8(x); \
+    } while (0)
+#define SHIFT17(x) \
+    do { \
+        SHIFT16(x); \
+        STATIC_SHIFT1(x); \
+    } while (0)
+#define SHIFT18(x) \
+    do { \
+        SHIFT16(x); \
+        STATIC_SHIFT2(x); \
+    } while (0)
+#define SHIFT19(x) \
+    do { \
+        SHIFT16(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT2(x); \
+    } while (0)
+#define SHIFT20(x) \
+    do { \
+        SHIFT16(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT21(x) \
+    do { \
+        SHIFT16(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT22(x) \
+    do { \
+        SHIFT16(x); \
+        STATIC_SHIFT2(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT23(x) \
+    do { \
+        SHIFT16(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT2(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT24(x) \
+    do { \
+        SHIFT16(x); \
+        STATIC_SHIFT8(x); \
+    } while (0)
+#define SHIFT25(x) \
+    do { \
+        SHIFT24(x); \
+        STATIC_SHIFT1(x); \
+    } while (0)
+#define SHIFT26(x) \
+    do { \
+        SHIFT24(x); \
+        STATIC_SHIFT2(x); \
+    } while (0)
+#define SHIFT27(x) \
+    do { \
+        SHIFT24(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT2(x); \
+    } while (0)
+#define SHIFT28(x) \
+    do { \
+        SHIFT24(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT29(x) \
+    do { \
+        SHIFT24(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT30(x) \
+    do { \
+        SHIFT24(x); \
+        STATIC_SHIFT2(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT31(x) \
+    do { \
+        SHIFT24(x); \
+        STATIC_SHIFT1(x); \
+        STATIC_SHIFT2(x); \
+        STATIC_SHIFT4(x); \
+    } while (0)
+#define SHIFT32(x) \
+    do { \
+        SHIFT24(x); \
+        STATIC_SHIFT8(x); \
+    } while (0)
+
+/*
+ * this function is used by 32-bit multiaccel matchers. 32-bit matchers accept
+ * a 32-bit integer as a buffer, where low 16 bits is movemask result and
+ * high 16 bits are "don't care" values. this function is not expected to return
+ * a result higher than 16.
+ */
+static really_inline
+const u8 *match32(const u8 *buf, const u32 z) {
+    if (unlikely(z != 0)) {
+        u32 pos = ctz32(z);
+        assert(pos < 16);
+        return buf + pos;
+    }
+    return NULL;
+}
+
+/*
+ * this function is used by 64-bit multiaccel matchers. 64-bit matchers accept
+ * a 64-bit integer as a buffer, where low 32 bits is movemask result and
+ * high 32 bits are "don't care" values. this function is not expected to return
+ * a result higher than 32.
+ */
+static really_inline
+const u8 *match64(const u8 *buf, const u64a z) {
+    if (unlikely(z != 0)) {
+        u32 pos = ctz64(z);
+        assert(pos < 32);
+        return buf + pos;
+    }
+    return NULL;
+}
+
+#endif /* MULTIACCEL_COMMON_H_ */
diff --git a/src/nfa/multiaccel_compilehelper.cpp b/src/nfa/multiaccel_compilehelper.cpp
new file mode 100644
index 00000000..f1cf2a4c
--- /dev/null
+++ b/src/nfa/multiaccel_compilehelper.cpp
@@ -0,0 +1,439 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "multiaccel_compilehelper.h"
+
+using namespace std;
+using namespace ue2;
+
+#ifdef DEBUG
+static const char* state_to_str[] = {
+    "FIRST_RUN",
+    "SECOND_RUN",
+    "WAITING_FOR_GRAB",
+    "FIRST_TAIL",
+    "SECOND_TAIL",
+    "STOPPED",
+    "INVALID"
+};
+static const char* type_to_str[] = {
+    "SHIFT",
+    "SHIFTGRAB",
+    "DOUBLESHIFT",
+    "DOUBLESHIFTGRAB",
+    "LONG",
+    "LONGGRAB",
+    "NONE"
+};
+
+static
+void dumpMultiaccelState(const accel_data &d) {
+    DEBUG_PRINTF("type: %s state: %s len1: %u tlen1: %u len2: %u tlen2: %u\n",
+                 type_to_str[(unsigned) d.type],
+                 state_to_str[(unsigned) d.state],
+                 d.len1, d.tlen1, d.len2, d.tlen2);
+}
+#endif
+
+/* stop all the matching. this may render most schemes invalid. */
+static
+void stop(accel_data &d) {
+    switch (d.state) {
+    case STATE_STOPPED:
+    case STATE_INVALID:
+        break;
+    case STATE_FIRST_TAIL:
+    case STATE_SECOND_RUN:
+        /*
+         * Shift matchers are special case, because they have "tails".
+         * When shift matcher reaches a mid/endpoint, tail mode is
+         * activated, which looks for more matches to extend the match.
+         *
+         * For example, consider pattern /a{5}ba{3}/. Under normal circumstances,
+         * long-grab matcher will be picked for this pattern (matching a run of a's,
+         * followed by a not-a), because doubleshift matcher would be confused by
+         * consecutive a's and would parse the pattern as a.{0}a.{0}a (two shifts
+         * by 1) and throw out the rest of the pattern.
+         *
+         * With tails, we defer ending the run until we actually run out of
+         * matching characters, so the above pattern will now be parsed by
+         * doubleshift matcher as /a.{3}a.{3}a/ (two shifts by 4).
+         *
+         * So if we are stopping shift matchers, we should check if we aren't in
+         * the process of matching first tail or second run. If we are, we can't
+         * finish the second run as we are stopping, but we can try and split
+         * the first tail instead to obtain a valid second run.
+         */
+        if ((d.type == MultibyteAccelInfo::MAT_DSHIFT ||
+                 d.type == MultibyteAccelInfo::MAT_DSHIFTGRAB) && d.tlen1 == 0) {
+            // can't split an empty void...
+            d.state = STATE_INVALID;
+            break;
+        }
+        d.len2 = 0;
+        d.state = STATE_STOPPED;
+        break;
+    case STATE_SECOND_TAIL:
+        d.state = STATE_STOPPED;
+        break;
+    case STATE_WAITING_FOR_GRAB:
+    case STATE_FIRST_RUN:
+        if (d.type == MultibyteAccelInfo::MAT_LONG) {
+            d.state = STATE_STOPPED;
+        } else {
+            d.state = STATE_INVALID;
+        }
+        break;
+    }
+}
+
+static
+void validate(accel_data &d, unsigned max_len) {
+    // try and fit in all our tails
+    if (d.len1 + d.tlen1 + d.len2 + d.tlen2 < max_len && d.len2 > 0) {
+        // case 1: everything fits in
+        d.len1 += d.tlen1;
+        d.len2 += d.tlen2;
+        d.tlen1 = 0;
+        d.tlen2 = 0;
+    } else if (d.len1 + d.tlen1 + d.len2 < max_len && d.len2 > 0) {
+        // case 2: everything but the second tail fits in
+        d.len1 += d.tlen1;
+        d.tlen1 = 0;
+        // try going for a partial tail
+        if (d.tlen2 != 0) {
+            int new_tlen2 = max_len - 1 - d.len1 - d.len2;
+            if (new_tlen2 > 0) {
+                d.len2 += new_tlen2;
+            }
+            d.tlen2 = 0;
+        }
+    } else if (d.len1 + d.tlen1 < max_len) {
+        // case 3: first run and its tail fits in
+        if (d.type == MultibyteAccelInfo::MAT_DSHIFT ||
+                 d.type == MultibyteAccelInfo::MAT_DSHIFTGRAB) {
+            // split the tail into a second run
+            d.len2 = d.tlen1;
+        } else {
+            d.len1 += d.tlen1;
+            d.len2 = 0;
+        }
+        d.tlen1 = 0;
+        d.tlen2 = 0;
+    } else if (d.len1 < max_len) {
+        // case 4: nothing but the first run fits in
+        // try going for a partial tail
+        if (d.tlen1 != 0) {
+            int new_tlen1 = max_len - 1 - d.len1;
+            if (new_tlen1 > 0) {
+                d.len1 += new_tlen1;
+            }
+            d.tlen1 = 0;
+        }
+        d.len2 = 0;
+        d.tlen2 = 0;
+    }
+    // if we removed our second run, doubleshift matchers are no longer valid
+    if ((d.type == MultibyteAccelInfo::MAT_DSHIFT ||
+                 d.type == MultibyteAccelInfo::MAT_DSHIFTGRAB) && d.len2 == 0) {
+        d.state = STATE_INVALID;
+    } else if ((d.type == MultibyteAccelInfo::MAT_LONG) && d.len1 >= max_len) {
+        // long matchers can just stop whenever they want to
+        d.len1 = max_len - 1;
+    }
+
+    // now, general sanity checks
+    if ((d.len1 + d.tlen1 + d.len2 + d.tlen2) >= max_len) {
+        d.state = STATE_INVALID;
+    }
+    if ((d.len1 + d.tlen1 + d.len2 + d.tlen2) < MULTIACCEL_MIN_LEN) {
+        d.state = STATE_INVALID;
+    }
+}
+
+static
+void match(accel_data &d, const CharReach &ref_cr, const CharReach &cur_cr) {
+    switch (d.type) {
+    case MultibyteAccelInfo::MAT_LONG:
+        {
+            /*
+             * For long matcher, we want lots of consecutive same-or-subset
+             * char-reaches
+             */
+            if ((ref_cr & cur_cr) == cur_cr) {
+                d.len1++;
+            } else {
+                d.state = STATE_STOPPED;
+            }
+        }
+        break;
+
+    case MultibyteAccelInfo::MAT_LONGGRAB:
+        {
+            /*
+             * For long-grab matcher, we want lots of consecutive same-or-subset
+             * char-reaches with a negative match in the end.
+             */
+            if ((ref_cr & cur_cr) == cur_cr) {
+                d.len1++;
+            } else if (!(ref_cr & cur_cr).any()) {
+                /* we grabbed, stop immediately */
+                d.state = STATE_STOPPED;
+            } else {
+                /* our run-n-grab was interrupted; mark as invalid */
+                d.state = STATE_INVALID;
+            }
+        }
+        break;
+
+    case MultibyteAccelInfo::MAT_SHIFTGRAB:
+        {
+            /*
+             * For shift-grab matcher, we want two matches separated by anything;
+             * however the second vertex *must* be a negative (non-overlapping) match.
+             *
+             * Shiftgrab matcher is identical to shift except for presence of grab.
+             */
+            if (d.state == STATE_WAITING_FOR_GRAB) {
+                if ((ref_cr & cur_cr).any()) {
+                    d.state = STATE_INVALID;
+                } else {
+                    d.state = STATE_FIRST_RUN;
+                    d.len1++;
+                }
+                return;
+            }
+        }
+        /* no break, falling through */
+    case MultibyteAccelInfo::MAT_SHIFT:
+        {
+            /*
+             * For shift-matcher, we want two matches separated by anything.
+             */
+            if (ref_cr == cur_cr) {
+                // keep matching tail
+                switch (d.state) {
+                case STATE_FIRST_RUN:
+                    d.state = STATE_FIRST_TAIL;
+                    break;
+                case STATE_FIRST_TAIL:
+                    d.tlen1++;
+                    break;
+                default:
+                    // shouldn't happen
+                    assert(0);
+                }
+            } else {
+                switch (d.state) {
+                case STATE_FIRST_RUN:
+                    // simply advance
+                    d.len1++;
+                    break;
+                case STATE_FIRST_TAIL:
+                    // we found a non-matching char after tail, so stop
+                    d.state = STATE_STOPPED;
+                    break;
+                default:
+                    // shouldn't happen
+                    assert(0);
+                }
+            }
+        }
+        break;
+
+    case MultibyteAccelInfo::MAT_DSHIFTGRAB:
+        {
+            /*
+             * For double shift-grab matcher, we want two matches separated by
+             * either negative matches or dots; however the second vertex *must*
+             * be a negative match.
+             *
+             * Doubleshiftgrab matcher is identical to doubleshift except for
+             * presence of grab.
+             */
+            if (d.state == STATE_WAITING_FOR_GRAB) {
+                if ((ref_cr & cur_cr).any()) {
+                    d.state = STATE_INVALID;
+                } else {
+                    d.state = STATE_FIRST_RUN;
+                    d.len1++;
+                }
+                return;
+            }
+        }
+        /* no break, falling through */
+    case MultibyteAccelInfo::MAT_DSHIFT:
+        {
+            /*
+             * For double shift matcher, we want three matches, each separated
+             * by a lot of anything.
+             *
+             * Doubleshift matcher is complicated by presence of tails.
+             */
+            if (ref_cr == cur_cr) {
+                // decide if we are activating second shift or matching tails
+                switch (d.state) {
+                case STATE_FIRST_RUN:
+                    d.state = STATE_FIRST_TAIL;
+                    d.len2 = 1; // we're now ready for our second run
+                    break;
+                case STATE_FIRST_TAIL:
+                    d.tlen1++;
+                    break;
+                case STATE_SECOND_RUN:
+                    d.state = STATE_SECOND_TAIL;
+                    break;
+                case STATE_SECOND_TAIL:
+                    d.tlen2++;
+                    break;
+                default:
+                    // shouldn't happen
+                    assert(0);
+                }
+            } else {
+                switch (d.state) {
+                case STATE_FIRST_RUN:
+                    d.len1++;
+                    break;
+                case STATE_FIRST_TAIL:
+                    // start second run
+                    d.state = STATE_SECOND_RUN;
+                    d.len2++;
+                    break;
+                case STATE_SECOND_RUN:
+                    d.len2++;
+                    break;
+                case STATE_SECOND_TAIL:
+                    // stop
+                    d.state = STATE_STOPPED;
+                    break;
+                default:
+                    // shouldn't happen
+                    assert(0);
+                }
+            }
+        }
+        break;
+
+    default:
+        // shouldn't happen
+        assert(0);
+        break;
+    }
+}
+
+MultiaccelCompileHelper::MultiaccelCompileHelper(const CharReach &ref_cr, u32 off,
+                                                 unsigned max_len) :
+        cr(ref_cr), offset(off), max_len(max_len) {
+    int accel_num = (int) MultibyteAccelInfo::MAT_MAX;
+    accels.resize(accel_num);
+
+    // mark everything as valid
+    for (int i = 0; i < accel_num; i++) {
+        accel_data &ad = accels[i];
+        ad.len1 = 1;
+        ad.type = (MultibyteAccelInfo::multiaccel_type) i;
+
+        /* for shift-grab matchers, we are waiting for the grab right at the start */
+        if (ad.type == MultibyteAccelInfo::MAT_SHIFTGRAB
+                || ad.type == MultibyteAccelInfo::MAT_DSHIFTGRAB) {
+            ad.state = STATE_WAITING_FOR_GRAB;
+        } else {
+            ad.state = STATE_FIRST_RUN;
+        }
+    }
+}
+
+bool MultiaccelCompileHelper::canAdvance() {
+    for (const accel_data &ad : accels) {
+        if (ad.state != STATE_STOPPED && ad.state != STATE_INVALID) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void MultiaccelCompileHelper::advance(const CharReach &cur_cr) {
+    for (accel_data &ad : accels) {
+        if (ad.state == STATE_STOPPED || ad.state == STATE_INVALID) {
+            continue;
+        }
+        match(ad, cr, cur_cr);
+#ifdef DEBUG
+        dumpMultiaccelState(ad);
+#endif
+    }
+}
+
+MultibyteAccelInfo MultiaccelCompileHelper::getBestScheme() {
+    int best_len = 0;
+    accel_data best;
+
+    DEBUG_PRINTF("Stopping multiaccel compile\n");
+
+    for (accel_data &ad : accels) {
+        // stop our matching
+        stop(ad);
+        validate(ad, max_len);
+
+#ifdef DEBUG
+        dumpMultiaccelState(ad);
+#endif
+
+        // skip invalid schemes
+        if (ad.state == STATE_INVALID) {
+            continue;
+        }
+        DEBUG_PRINTF("Marking as viable\n");
+
+        // TODO: relative strengths of accel schemes? maybe e.g. a shorter
+        // long match would in some cases be preferable to a longer
+        // double shift match (for example, depending on length)?
+        int as_len = ad.len1 + ad.len2;
+        if (as_len >= best_len) {
+            DEBUG_PRINTF("Marking as best\n");
+            best_len = as_len;
+            best = ad;
+        }
+    }
+    // if we found at least one accel scheme, return it
+    if (best.state != STATE_INVALID) {
+#ifdef DEBUG
+        DEBUG_PRINTF("Picked best multiaccel state:\n");
+        dumpMultiaccelState(best);
+#endif
+        MultibyteAccelInfo info;
+        info.cr = cr;
+        info.offset = offset;
+        info.len1 = best.len1;
+        info.len2 = best.len2;
+        info.type = best.type;
+        return info;
+    }
+    return MultibyteAccelInfo();
+}
diff --git a/src/util/report.cpp b/src/nfa/multiaccel_compilehelper.h
similarity index 57%
rename from src/util/report.cpp
rename to src/nfa/multiaccel_compilehelper.h
index 58f10fd4..27dbe634 100644
--- a/src/util/report.cpp
+++ b/src/nfa/multiaccel_compilehelper.h
@@ -26,44 +26,50 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "internal_report.h"
-#include "report.h"
-#include "report_manager.h"
+#ifndef MULTIACCELCOMPILE_H_
+#define MULTIACCELCOMPILE_H_
+
+#include "ue2common.h"
+
+#include "nfagraph/ng_limex_accel.h"
+
+#include <vector>
 
 namespace ue2 {
 
-void writeInternalReport(const Report &report, const ReportManager &rm,
-                         internal_report *ir) {
-    assert(ir);
-    assert(ISALIGNED(ir));
+/* accel scheme state machine */
+enum accel_scheme_state {
+    STATE_FIRST_RUN,
+    STATE_SECOND_RUN,
+    STATE_WAITING_FOR_GRAB,
+    STATE_FIRST_TAIL,
+    STATE_SECOND_TAIL,
+    STATE_STOPPED,
+    STATE_INVALID
+};
 
-    ir->type = report.type;
-    ir->hasBounds = report.hasBounds() ? 1 : 0;
-    ir->quashSom = report.quashSom ? 1 : 0;
-    ir->minOffset = report.minOffset;
-    ir->maxOffset = report.maxOffset;
-    ir->minLength = report.minLength;
-    ir->ekey = report.ekey;
-    ir->offsetAdjust = report.offsetAdjust;
-    ir->onmatch = report.onmatch;
+struct accel_data {
+    MultibyteAccelInfo::multiaccel_type type = MultibyteAccelInfo::MAT_NONE;
+    accel_scheme_state state = STATE_INVALID;
+    unsigned len1 = 0; /* length of first run */
+    unsigned len2 = 0; /* length of second run, if present */
+    unsigned tlen1 = 0; /* first tail length */
+    unsigned tlen2 = 0; /* second tail length */
+};
 
-    switch (report.type) {
-    case INTERNAL_ROSE_CHAIN:
-        ir->aux.topSquashDistance = report.topSquashDistance;
-        break;
-    case EXTERNAL_CALLBACK_SOM_REV_NFA:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE:
-        ir->aux.revNfaIndex = report.revNfaIndex;
-        break;
-    default:
-        ir->aux.somDistance = report.somDistance;
-        break;
-    }
+class MultiaccelCompileHelper {
+private:
+    const CharReach &cr;
+    u32 offset;
+    std::vector<accel_data> accels;
+    unsigned max_len;
+public:
+    MultiaccelCompileHelper(const CharReach &cr, u32 off, unsigned max_len);
+    bool canAdvance();
+    MultibyteAccelInfo getBestScheme();
+    void advance(const ue2::CharReach &cr);
+};
 
-    // Dedupe keys are managed by ReportManager.
-    ir->dkey = rm.getDkey(report);
-}
+}; // namespace
 
-} // namespace ue2
+#endif /* MULTIACCELCOMPILE_H_ */
diff --git a/src/nfa/multiaccel_doubleshift.h b/src/nfa/multiaccel_doubleshift.h
new file mode 100644
index 00000000..7ed7534c
--- /dev/null
+++ b/src/nfa/multiaccel_doubleshift.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTIACCEL_DOUBLESHIFT_H_
+#define MULTIACCEL_DOUBLESHIFT_H_
+
+#include "multiaccel_common.h"
+
+#define DOUBLESHIFT_MATCH(len, match_t, match_sz) \
+    static really_inline \
+    const u8 * JOIN4(doubleshiftMatch_, match_sz, _, len)(const u8 *buf, match_t z, u32 len2) {\
+        if (unlikely(z)) { \
+            match_t tmp = z; \
+            z |= ((match_t) (1 << (len)) - 1) << (match_sz / 2); \
+            tmp |= ((match_t) (1 << (len + len2)) - 1) << (match_sz / 2); \
+            VARISHIFT(z, z, len); \
+            VARISHIFT(tmp, tmp, len2); \
+            VARISHIFT(tmp, z, len); \
+            return JOIN(match, match_sz)(buf, z); \
+        } \
+        return NULL; \
+    }
+
+#define DOUBLESHIFT_MATCH_32_DEF(n) \
+        DOUBLESHIFT_MATCH(n, u32, 32)
+#define DOUBLESHIFT_MATCH_64_DEF(n) \
+        DOUBLESHIFT_MATCH(n, u64a, 64)
+#define DOUBLESHIFT_MATCH_DEF(n) \
+    DOUBLESHIFT_MATCH_32_DEF(n) \
+    DOUBLESHIFT_MATCH_64_DEF(n)
+
+DOUBLESHIFT_MATCH_DEF(1)
+DOUBLESHIFT_MATCH_DEF(2)
+DOUBLESHIFT_MATCH_DEF(3)
+DOUBLESHIFT_MATCH_DEF(4)
+DOUBLESHIFT_MATCH_DEF(5)
+DOUBLESHIFT_MATCH_DEF(6)
+DOUBLESHIFT_MATCH_DEF(7)
+DOUBLESHIFT_MATCH_DEF(8)
+DOUBLESHIFT_MATCH_DEF(9)
+DOUBLESHIFT_MATCH_DEF(10)
+DOUBLESHIFT_MATCH_DEF(11)
+DOUBLESHIFT_MATCH_DEF(12)
+DOUBLESHIFT_MATCH_DEF(13)
+DOUBLESHIFT_MATCH_DEF(14)
+DOUBLESHIFT_MATCH_DEF(15)
+DOUBLESHIFT_MATCH_64_DEF(16)
+DOUBLESHIFT_MATCH_64_DEF(17)
+DOUBLESHIFT_MATCH_64_DEF(18)
+DOUBLESHIFT_MATCH_64_DEF(19)
+DOUBLESHIFT_MATCH_64_DEF(20)
+DOUBLESHIFT_MATCH_64_DEF(21)
+DOUBLESHIFT_MATCH_64_DEF(22)
+DOUBLESHIFT_MATCH_64_DEF(23)
+DOUBLESHIFT_MATCH_64_DEF(24)
+DOUBLESHIFT_MATCH_64_DEF(25)
+DOUBLESHIFT_MATCH_64_DEF(26)
+DOUBLESHIFT_MATCH_64_DEF(27)
+DOUBLESHIFT_MATCH_64_DEF(28)
+DOUBLESHIFT_MATCH_64_DEF(29)
+DOUBLESHIFT_MATCH_64_DEF(30)
+DOUBLESHIFT_MATCH_64_DEF(31)
+
+static
+const UNUSED u8 * (*doubleshift_match_funcs_32[])(const u8 *buf, u32 z, u32 len2) =
+{
+// skip the first
+    0,
+    &doubleshiftMatch_32_1,
+    &doubleshiftMatch_32_2,
+    &doubleshiftMatch_32_3,
+    &doubleshiftMatch_32_4,
+    &doubleshiftMatch_32_5,
+    &doubleshiftMatch_32_6,
+    &doubleshiftMatch_32_7,
+    &doubleshiftMatch_32_8,
+    &doubleshiftMatch_32_9,
+    &doubleshiftMatch_32_10,
+    &doubleshiftMatch_32_11,
+    &doubleshiftMatch_32_12,
+    &doubleshiftMatch_32_13,
+    &doubleshiftMatch_32_14,
+    &doubleshiftMatch_32_15,
+};
+
+static
+const UNUSED u8 * (*doubleshift_match_funcs_64[])(const u8 *buf, u64a z, u32 len2) =
+{
+// skip the first
+    0,
+    &doubleshiftMatch_64_1,
+    &doubleshiftMatch_64_2,
+    &doubleshiftMatch_64_3,
+    &doubleshiftMatch_64_4,
+    &doubleshiftMatch_64_5,
+    &doubleshiftMatch_64_6,
+    &doubleshiftMatch_64_7,
+    &doubleshiftMatch_64_8,
+    &doubleshiftMatch_64_9,
+    &doubleshiftMatch_64_10,
+    &doubleshiftMatch_64_11,
+    &doubleshiftMatch_64_12,
+    &doubleshiftMatch_64_13,
+    &doubleshiftMatch_64_14,
+    &doubleshiftMatch_64_15,
+    &doubleshiftMatch_64_16,
+    &doubleshiftMatch_64_17,
+    &doubleshiftMatch_64_18,
+    &doubleshiftMatch_64_19,
+    &doubleshiftMatch_64_20,
+    &doubleshiftMatch_64_21,
+    &doubleshiftMatch_64_22,
+    &doubleshiftMatch_64_23,
+    &doubleshiftMatch_64_24,
+    &doubleshiftMatch_64_25,
+    &doubleshiftMatch_64_26,
+    &doubleshiftMatch_64_27,
+    &doubleshiftMatch_64_28,
+    &doubleshiftMatch_64_29,
+    &doubleshiftMatch_64_30,
+    &doubleshiftMatch_64_31,
+};
+
+#endif /* MULTIACCEL_DOUBLESHIFT_H_ */
diff --git a/src/nfa/multiaccel_doubleshiftgrab.h b/src/nfa/multiaccel_doubleshiftgrab.h
new file mode 100644
index 00000000..51955b4a
--- /dev/null
+++ b/src/nfa/multiaccel_doubleshiftgrab.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTIACCEL_DOUBLESHIFTGRAB_H_
+#define MULTIACCEL_DOUBLESHIFTGRAB_H_
+
+#include "multiaccel_common.h"
+
+#define DOUBLESHIFTGRAB_MATCH(len, match_t, match_sz) \
+    static really_inline \
+    const u8 * JOIN4(doubleshiftgrabMatch_, match_sz, _, len)(const u8 *buf, match_t z, u32 len2) {\
+        if (unlikely(z)) { \
+            match_t neg = ~z; \
+            match_t tmp = z; \
+            z |= ((match_t) (1 << (len)) - 1) << (match_sz / 2); \
+            tmp |= ((match_t) (1 << (len + len2)) - 1) << (match_sz / 2); \
+            neg |= ((match_t) (1 << len) - 1) << (match_sz / 2); \
+            VARISHIFT(z, z, len); \
+            VARISHIFT(tmp, tmp, len2); \
+            VARISHIFT(neg, z, 1); \
+            VARISHIFT(tmp, z, len); \
+            return JOIN(match, match_sz)(buf, z); \
+        } \
+        return NULL; \
+    }
+
+#define DOUBLESHIFTGRAB_MATCH_32_DEF(n) \
+        DOUBLESHIFTGRAB_MATCH(n, u32, 32)
+#define DOUBLESHIFTGRAB_MATCH_64_DEF(n) \
+        DOUBLESHIFTGRAB_MATCH(n, u64a, 64)
+#define DOUBLESHIFTGRAB_MATCH_DEF(n) \
+    DOUBLESHIFTGRAB_MATCH_32_DEF(n) \
+    DOUBLESHIFTGRAB_MATCH_64_DEF(n)
+
+DOUBLESHIFTGRAB_MATCH_DEF(1)
+DOUBLESHIFTGRAB_MATCH_DEF(2)
+DOUBLESHIFTGRAB_MATCH_DEF(3)
+DOUBLESHIFTGRAB_MATCH_DEF(4)
+DOUBLESHIFTGRAB_MATCH_DEF(5)
+DOUBLESHIFTGRAB_MATCH_DEF(6)
+DOUBLESHIFTGRAB_MATCH_DEF(7)
+DOUBLESHIFTGRAB_MATCH_DEF(8)
+DOUBLESHIFTGRAB_MATCH_DEF(9)
+DOUBLESHIFTGRAB_MATCH_DEF(10)
+DOUBLESHIFTGRAB_MATCH_DEF(11)
+DOUBLESHIFTGRAB_MATCH_DEF(12)
+DOUBLESHIFTGRAB_MATCH_DEF(13)
+DOUBLESHIFTGRAB_MATCH_DEF(14)
+DOUBLESHIFTGRAB_MATCH_DEF(15)
+DOUBLESHIFTGRAB_MATCH_64_DEF(16)
+DOUBLESHIFTGRAB_MATCH_64_DEF(17)
+DOUBLESHIFTGRAB_MATCH_64_DEF(18)
+DOUBLESHIFTGRAB_MATCH_64_DEF(19)
+DOUBLESHIFTGRAB_MATCH_64_DEF(20)
+DOUBLESHIFTGRAB_MATCH_64_DEF(21)
+DOUBLESHIFTGRAB_MATCH_64_DEF(22)
+DOUBLESHIFTGRAB_MATCH_64_DEF(23)
+DOUBLESHIFTGRAB_MATCH_64_DEF(24)
+DOUBLESHIFTGRAB_MATCH_64_DEF(25)
+DOUBLESHIFTGRAB_MATCH_64_DEF(26)
+DOUBLESHIFTGRAB_MATCH_64_DEF(27)
+DOUBLESHIFTGRAB_MATCH_64_DEF(28)
+DOUBLESHIFTGRAB_MATCH_64_DEF(29)
+DOUBLESHIFTGRAB_MATCH_64_DEF(30)
+DOUBLESHIFTGRAB_MATCH_64_DEF(31)
+
+static
+const UNUSED u8 * (*doubleshiftgrab_match_funcs_32[])(const u8 *buf, u32 z, u32 len2) =
+{
+// skip the first
+    0,
+    &doubleshiftgrabMatch_32_1,
+    &doubleshiftgrabMatch_32_2,
+    &doubleshiftgrabMatch_32_3,
+    &doubleshiftgrabMatch_32_4,
+    &doubleshiftgrabMatch_32_5,
+    &doubleshiftgrabMatch_32_6,
+    &doubleshiftgrabMatch_32_7,
+    &doubleshiftgrabMatch_32_8,
+    &doubleshiftgrabMatch_32_9,
+    &doubleshiftgrabMatch_32_10,
+    &doubleshiftgrabMatch_32_11,
+    &doubleshiftgrabMatch_32_12,
+    &doubleshiftgrabMatch_32_13,
+    &doubleshiftgrabMatch_32_14,
+    &doubleshiftgrabMatch_32_15,
+};
+
+static
+const UNUSED u8 * (*doubleshiftgrab_match_funcs_64[])(const u8 *buf, u64a z, u32 len2) =
+{
+// skip the first
+    0,
+    &doubleshiftgrabMatch_64_1,
+    &doubleshiftgrabMatch_64_2,
+    &doubleshiftgrabMatch_64_3,
+    &doubleshiftgrabMatch_64_4,
+    &doubleshiftgrabMatch_64_5,
+    &doubleshiftgrabMatch_64_6,
+    &doubleshiftgrabMatch_64_7,
+    &doubleshiftgrabMatch_64_8,
+    &doubleshiftgrabMatch_64_9,
+    &doubleshiftgrabMatch_64_10,
+    &doubleshiftgrabMatch_64_11,
+    &doubleshiftgrabMatch_64_12,
+    &doubleshiftgrabMatch_64_13,
+    &doubleshiftgrabMatch_64_14,
+    &doubleshiftgrabMatch_64_15,
+    &doubleshiftgrabMatch_64_16,
+    &doubleshiftgrabMatch_64_17,
+    &doubleshiftgrabMatch_64_18,
+    &doubleshiftgrabMatch_64_19,
+    &doubleshiftgrabMatch_64_20,
+    &doubleshiftgrabMatch_64_21,
+    &doubleshiftgrabMatch_64_22,
+    &doubleshiftgrabMatch_64_23,
+    &doubleshiftgrabMatch_64_24,
+    &doubleshiftgrabMatch_64_25,
+    &doubleshiftgrabMatch_64_26,
+    &doubleshiftgrabMatch_64_27,
+    &doubleshiftgrabMatch_64_28,
+    &doubleshiftgrabMatch_64_29,
+    &doubleshiftgrabMatch_64_30,
+    &doubleshiftgrabMatch_64_31,
+};
+
+#endif /* MULTIACCEL_DOUBLESHIFTGRAB_H_ */
diff --git a/src/nfa/multiaccel_long.h b/src/nfa/multiaccel_long.h
new file mode 100644
index 00000000..515f0bc2
--- /dev/null
+++ b/src/nfa/multiaccel_long.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTIACCEL_LONG_H_
+#define MULTIACCEL_LONG_H_
+
+#include "multiaccel_common.h"
+
+#define LONG_MATCH(len, match_t, match_sz) \
+    static really_inline \
+    const u8 * JOIN4(longMatch_, match_sz, _, len)(const u8 *buf, match_t z) { \
+        if (unlikely(z)) { \
+            z |= ((match_t) (1 << (len - 1)) - 1) << (match_sz / 2); \
+            JOIN(SHIFT, len)(z); \
+            return JOIN(match, match_sz)(buf, z); \
+        } \
+        return NULL; \
+    }
+
+#define LONG_MATCH_32_DEF(n) \
+        LONG_MATCH(n, u32, 32)
+#define LONG_MATCH_64_DEF(n) \
+        LONG_MATCH(n, u64a, 64)
+#define LONG_MATCH_DEF(n) \
+    LONG_MATCH_32_DEF(n) \
+    LONG_MATCH_64_DEF(n)
+
+LONG_MATCH_DEF(1)
+LONG_MATCH_DEF(2)
+LONG_MATCH_DEF(3)
+LONG_MATCH_DEF(4)
+LONG_MATCH_DEF(5)
+LONG_MATCH_DEF(6)
+LONG_MATCH_DEF(7)
+LONG_MATCH_DEF(8)
+LONG_MATCH_DEF(9)
+LONG_MATCH_DEF(10)
+LONG_MATCH_DEF(11)
+LONG_MATCH_DEF(12)
+LONG_MATCH_DEF(13)
+LONG_MATCH_DEF(14)
+LONG_MATCH_DEF(15)
+LONG_MATCH_64_DEF(16)
+LONG_MATCH_64_DEF(17)
+LONG_MATCH_64_DEF(18)
+LONG_MATCH_64_DEF(19)
+LONG_MATCH_64_DEF(20)
+LONG_MATCH_64_DEF(21)
+LONG_MATCH_64_DEF(22)
+LONG_MATCH_64_DEF(23)
+LONG_MATCH_64_DEF(24)
+LONG_MATCH_64_DEF(25)
+LONG_MATCH_64_DEF(26)
+LONG_MATCH_64_DEF(27)
+LONG_MATCH_64_DEF(28)
+LONG_MATCH_64_DEF(29)
+LONG_MATCH_64_DEF(30)
+LONG_MATCH_64_DEF(31)
+
+static
+const UNUSED u8 *(*long_match_funcs_32[])(const u8 *buf, u32 z) =
+{
+    // skip the first three
+     0,
+     &longMatch_32_1,
+     &longMatch_32_2,
+     &longMatch_32_3,
+     &longMatch_32_4,
+     &longMatch_32_5,
+     &longMatch_32_6,
+     &longMatch_32_7,
+     &longMatch_32_8,
+     &longMatch_32_9,
+     &longMatch_32_10,
+     &longMatch_32_11,
+     &longMatch_32_12,
+     &longMatch_32_13,
+     &longMatch_32_14,
+     &longMatch_32_15,
+ };
+
+static
+const UNUSED u8 *(*long_match_funcs_64[])(const u8 *buf, u64a z) =
+{
+// skip the first three
+    0,
+    &longMatch_64_1,
+    &longMatch_64_2,
+    &longMatch_64_3,
+    &longMatch_64_4,
+    &longMatch_64_5,
+    &longMatch_64_6,
+    &longMatch_64_7,
+    &longMatch_64_8,
+    &longMatch_64_9,
+    &longMatch_64_10,
+    &longMatch_64_11,
+    &longMatch_64_12,
+    &longMatch_64_13,
+    &longMatch_64_14,
+    &longMatch_64_15,
+    &longMatch_64_16,
+    &longMatch_64_17,
+    &longMatch_64_18,
+    &longMatch_64_19,
+    &longMatch_64_20,
+    &longMatch_64_21,
+    &longMatch_64_22,
+    &longMatch_64_23,
+    &longMatch_64_24,
+    &longMatch_64_25,
+    &longMatch_64_26,
+    &longMatch_64_27,
+    &longMatch_64_28,
+    &longMatch_64_29,
+    &longMatch_64_30,
+    &longMatch_64_31,
+};
+
+#endif /* MULTIACCEL_LONG_H_ */
diff --git a/src/nfa/multiaccel_longgrab.h b/src/nfa/multiaccel_longgrab.h
new file mode 100644
index 00000000..09daaf82
--- /dev/null
+++ b/src/nfa/multiaccel_longgrab.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTIACCEL_LONGGRAB_H_
+#define MULTIACCEL_LONGGRAB_H_
+
+#include "multiaccel_common.h"
+
+#define LONGGRAB_MATCH(len, match_t, match_sz) \
+    static really_inline \
+    const u8 * JOIN4(longgrabMatch_, match_sz, _, len)(const u8 *buf, match_t z) { \
+        if (unlikely(z)) { \
+            match_t tmp = ~z; \
+            tmp |= ((match_t) (1 << len) - 1) << (match_sz / 2); \
+            z |= ((match_t) (1 << (len - 1)) - 1) << (match_sz / 2); \
+            JOIN(SHIFT, len)(z); \
+            VARISHIFT(tmp, z, len); \
+            return JOIN(match, match_sz)(buf, z); \
+        } \
+        return NULL; \
+    }
+
+#define LONGGRAB_MATCH_32_DEF(n) \
+        LONGGRAB_MATCH(n, u32, 32)
+#define LONGGRAB_MATCH_64_DEF(n) \
+        LONGGRAB_MATCH(n, u64a, 64)
+#define LONGGRAB_MATCH_DEF(n) \
+    LONGGRAB_MATCH_32_DEF(n) \
+    LONGGRAB_MATCH_64_DEF(n)
+
+LONGGRAB_MATCH_DEF(1)
+LONGGRAB_MATCH_DEF(2)
+LONGGRAB_MATCH_DEF(3)
+LONGGRAB_MATCH_DEF(4)
+LONGGRAB_MATCH_DEF(5)
+LONGGRAB_MATCH_DEF(6)
+LONGGRAB_MATCH_DEF(7)
+LONGGRAB_MATCH_DEF(8)
+LONGGRAB_MATCH_DEF(9)
+LONGGRAB_MATCH_DEF(10)
+LONGGRAB_MATCH_DEF(11)
+LONGGRAB_MATCH_DEF(12)
+LONGGRAB_MATCH_DEF(13)
+LONGGRAB_MATCH_DEF(14)
+LONGGRAB_MATCH_DEF(15)
+LONGGRAB_MATCH_64_DEF(16)
+LONGGRAB_MATCH_64_DEF(17)
+LONGGRAB_MATCH_64_DEF(18)
+LONGGRAB_MATCH_64_DEF(19)
+LONGGRAB_MATCH_64_DEF(20)
+LONGGRAB_MATCH_64_DEF(21)
+LONGGRAB_MATCH_64_DEF(22)
+LONGGRAB_MATCH_64_DEF(23)
+LONGGRAB_MATCH_64_DEF(24)
+LONGGRAB_MATCH_64_DEF(25)
+LONGGRAB_MATCH_64_DEF(26)
+LONGGRAB_MATCH_64_DEF(27)
+LONGGRAB_MATCH_64_DEF(28)
+LONGGRAB_MATCH_64_DEF(29)
+LONGGRAB_MATCH_64_DEF(30)
+LONGGRAB_MATCH_64_DEF(31)
+
+static
+const UNUSED u8 *(*longgrab_match_funcs_32[])(const u8 *buf, u32 z) =
+{
+// skip the first three
+     0,
+     &longgrabMatch_32_1,
+     &longgrabMatch_32_2,
+     &longgrabMatch_32_3,
+     &longgrabMatch_32_4,
+     &longgrabMatch_32_5,
+     &longgrabMatch_32_6,
+     &longgrabMatch_32_7,
+     &longgrabMatch_32_8,
+     &longgrabMatch_32_9,
+     &longgrabMatch_32_10,
+     &longgrabMatch_32_11,
+     &longgrabMatch_32_12,
+     &longgrabMatch_32_13,
+     &longgrabMatch_32_14,
+     &longgrabMatch_32_15,
+ };
+
+static
+const UNUSED u8 *(*longgrab_match_funcs_64[])(const u8 *buf, u64a z) =
+{
+// skip the first three
+    0,
+    &longgrabMatch_64_1,
+    &longgrabMatch_64_2,
+    &longgrabMatch_64_3,
+    &longgrabMatch_64_4,
+    &longgrabMatch_64_5,
+    &longgrabMatch_64_6,
+    &longgrabMatch_64_7,
+    &longgrabMatch_64_8,
+    &longgrabMatch_64_9,
+    &longgrabMatch_64_10,
+    &longgrabMatch_64_11,
+    &longgrabMatch_64_12,
+    &longgrabMatch_64_13,
+    &longgrabMatch_64_14,
+    &longgrabMatch_64_15,
+    &longgrabMatch_64_16,
+    &longgrabMatch_64_17,
+    &longgrabMatch_64_18,
+    &longgrabMatch_64_19,
+    &longgrabMatch_64_20,
+    &longgrabMatch_64_21,
+    &longgrabMatch_64_22,
+    &longgrabMatch_64_23,
+    &longgrabMatch_64_24,
+    &longgrabMatch_64_25,
+    &longgrabMatch_64_26,
+    &longgrabMatch_64_27,
+    &longgrabMatch_64_28,
+    &longgrabMatch_64_29,
+    &longgrabMatch_64_30,
+    &longgrabMatch_64_31,
+};
+
+#endif /* MULTIACCEL_LONGGRAB_H_ */
diff --git a/src/nfa/multiaccel_shift.h b/src/nfa/multiaccel_shift.h
new file mode 100644
index 00000000..fd362a8b
--- /dev/null
+++ b/src/nfa/multiaccel_shift.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTIACCEL_SHIFT_H_
+#define MULTIACCEL_SHIFT_H_
+
+#include "multiaccel_common.h"
+
+#define SHIFT_MATCH(len, match_t, match_sz) \
+    static really_inline \
+    const u8 * JOIN4(shiftMatch_, match_sz, _, len)(const u8 *buf, match_t z) {\
+        if (unlikely(z)) { \
+            z |= ((match_t) (1 << (len)) - 1) << (match_sz / 2); \
+            VARISHIFT(z, z, len); \
+            return JOIN(match, match_sz)(buf, z); \
+        } \
+        return NULL; \
+    }
+
+#define SHIFT_MATCH_32_DEF(n) \
+        SHIFT_MATCH(n, u32, 32)
+#define SHIFT_MATCH_64_DEF(n) \
+        SHIFT_MATCH(n, u64a, 64)
+#define SHIFT_MATCH_DEF(n) \
+    SHIFT_MATCH_32_DEF(n) \
+    SHIFT_MATCH_64_DEF(n)
+
+SHIFT_MATCH_DEF(1)
+SHIFT_MATCH_DEF(2)
+SHIFT_MATCH_DEF(3)
+SHIFT_MATCH_DEF(4)
+SHIFT_MATCH_DEF(5)
+SHIFT_MATCH_DEF(6)
+SHIFT_MATCH_DEF(7)
+SHIFT_MATCH_DEF(8)
+SHIFT_MATCH_DEF(9)
+SHIFT_MATCH_DEF(10)
+SHIFT_MATCH_DEF(11)
+SHIFT_MATCH_DEF(12)
+SHIFT_MATCH_DEF(13)
+SHIFT_MATCH_DEF(14)
+SHIFT_MATCH_DEF(15)
+SHIFT_MATCH_64_DEF(16)
+SHIFT_MATCH_64_DEF(17)
+SHIFT_MATCH_64_DEF(18)
+SHIFT_MATCH_64_DEF(19)
+SHIFT_MATCH_64_DEF(20)
+SHIFT_MATCH_64_DEF(21)
+SHIFT_MATCH_64_DEF(22)
+SHIFT_MATCH_64_DEF(23)
+SHIFT_MATCH_64_DEF(24)
+SHIFT_MATCH_64_DEF(25)
+SHIFT_MATCH_64_DEF(26)
+SHIFT_MATCH_64_DEF(27)
+SHIFT_MATCH_64_DEF(28)
+SHIFT_MATCH_64_DEF(29)
+SHIFT_MATCH_64_DEF(30)
+SHIFT_MATCH_64_DEF(31)
+
+static
+const UNUSED u8 * (*shift_match_funcs_32[])(const u8 *buf, u32 z) =
+{
+// skip the first
+   0,
+   &shiftMatch_32_1,
+   &shiftMatch_32_2,
+   &shiftMatch_32_3,
+   &shiftMatch_32_4,
+   &shiftMatch_32_5,
+   &shiftMatch_32_6,
+   &shiftMatch_32_7,
+   &shiftMatch_32_8,
+   &shiftMatch_32_9,
+   &shiftMatch_32_10,
+   &shiftMatch_32_11,
+   &shiftMatch_32_12,
+   &shiftMatch_32_13,
+   &shiftMatch_32_14,
+   &shiftMatch_32_15,
+};
+
+static
+const UNUSED u8 * (*shift_match_funcs_64[])(const u8 *buf, u64a z) =
+{
+// skip the first
+    0,
+    &shiftMatch_64_1,
+    &shiftMatch_64_2,
+    &shiftMatch_64_3,
+    &shiftMatch_64_4,
+    &shiftMatch_64_5,
+    &shiftMatch_64_6,
+    &shiftMatch_64_7,
+    &shiftMatch_64_8,
+    &shiftMatch_64_9,
+    &shiftMatch_64_10,
+    &shiftMatch_64_11,
+    &shiftMatch_64_12,
+    &shiftMatch_64_13,
+    &shiftMatch_64_14,
+    &shiftMatch_64_15,
+    &shiftMatch_64_16,
+    &shiftMatch_64_17,
+    &shiftMatch_64_18,
+    &shiftMatch_64_19,
+    &shiftMatch_64_20,
+    &shiftMatch_64_21,
+    &shiftMatch_64_22,
+    &shiftMatch_64_23,
+    &shiftMatch_64_24,
+    &shiftMatch_64_25,
+    &shiftMatch_64_26,
+    &shiftMatch_64_27,
+    &shiftMatch_64_28,
+    &shiftMatch_64_29,
+    &shiftMatch_64_30,
+    &shiftMatch_64_31,
+};
+
+#endif /* MULTIACCEL_SHIFT_H_ */
diff --git a/src/nfa/multiaccel_shiftgrab.h b/src/nfa/multiaccel_shiftgrab.h
new file mode 100644
index 00000000..032ed086
--- /dev/null
+++ b/src/nfa/multiaccel_shiftgrab.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTIACCEL_SHIFTGRAB_H_
+#define MULTIACCEL_SHIFTGRAB_H_
+
+#include "multiaccel_common.h"
+
+#define SHIFTGRAB_MATCH(len, match_t, match_sz) \
+    static really_inline \
+    const u8 * JOIN4(shiftgrabMatch_, match_sz, _, len)(const u8 *buf, match_t z) {\
+        if (unlikely(z)) { \
+            match_t tmp = ~z; \
+            z |= ((match_t) (1 << (len)) - 1) << (match_sz / 2); \
+            tmp |= ((match_t) (1 << len) - 1) << (match_sz / 2); \
+            VARISHIFT(z, z, len); \
+            VARISHIFT(tmp, z, 1); \
+            return JOIN(match, match_sz)(buf, z); \
+        } \
+        return NULL; \
+    }
+
+#define SHIFTGRAB_MATCH_32_DEF(n) \
+        SHIFTGRAB_MATCH(n, u32, 32)
+#define SHIFTGRAB_MATCH_64_DEF(n) \
+        SHIFTGRAB_MATCH(n, u64a, 64)
+#define SHIFTGRAB_MATCH_DEF(n) \
+    SHIFTGRAB_MATCH_32_DEF(n) \
+    SHIFTGRAB_MATCH_64_DEF(n)
+
+SHIFTGRAB_MATCH_DEF(1)
+SHIFTGRAB_MATCH_DEF(2)
+SHIFTGRAB_MATCH_DEF(3)
+SHIFTGRAB_MATCH_DEF(4)
+SHIFTGRAB_MATCH_DEF(5)
+SHIFTGRAB_MATCH_DEF(6)
+SHIFTGRAB_MATCH_DEF(7)
+SHIFTGRAB_MATCH_DEF(8)
+SHIFTGRAB_MATCH_DEF(9)
+SHIFTGRAB_MATCH_DEF(10)
+SHIFTGRAB_MATCH_DEF(11)
+SHIFTGRAB_MATCH_DEF(12)
+SHIFTGRAB_MATCH_DEF(13)
+SHIFTGRAB_MATCH_DEF(14)
+SHIFTGRAB_MATCH_DEF(15)
+SHIFTGRAB_MATCH_64_DEF(16)
+SHIFTGRAB_MATCH_64_DEF(17)
+SHIFTGRAB_MATCH_64_DEF(18)
+SHIFTGRAB_MATCH_64_DEF(19)
+SHIFTGRAB_MATCH_64_DEF(20)
+SHIFTGRAB_MATCH_64_DEF(21)
+SHIFTGRAB_MATCH_64_DEF(22)
+SHIFTGRAB_MATCH_64_DEF(23)
+SHIFTGRAB_MATCH_64_DEF(24)
+SHIFTGRAB_MATCH_64_DEF(25)
+SHIFTGRAB_MATCH_64_DEF(26)
+SHIFTGRAB_MATCH_64_DEF(27)
+SHIFTGRAB_MATCH_64_DEF(28)
+SHIFTGRAB_MATCH_64_DEF(29)
+SHIFTGRAB_MATCH_64_DEF(30)
+SHIFTGRAB_MATCH_64_DEF(31)
+
+static
+const UNUSED u8 * (*shiftgrab_match_funcs_32[])(const u8 *buf, u32 z) =
+{
+// skip the first
+    0,
+    &shiftgrabMatch_32_1,
+    &shiftgrabMatch_32_2,
+    &shiftgrabMatch_32_3,
+    &shiftgrabMatch_32_4,
+    &shiftgrabMatch_32_5,
+    &shiftgrabMatch_32_6,
+    &shiftgrabMatch_32_7,
+    &shiftgrabMatch_32_8,
+    &shiftgrabMatch_32_9,
+    &shiftgrabMatch_32_10,
+    &shiftgrabMatch_32_11,
+    &shiftgrabMatch_32_12,
+    &shiftgrabMatch_32_13,
+    &shiftgrabMatch_32_14,
+    &shiftgrabMatch_32_15,
+};
+
+static
+const UNUSED u8 * (*shiftgrab_match_funcs_64[])(const u8 *buf, u64a z) =
+                                                       {
+// skip the first
+    0,
+    &shiftgrabMatch_64_1,
+    &shiftgrabMatch_64_2,
+    &shiftgrabMatch_64_3,
+    &shiftgrabMatch_64_4,
+    &shiftgrabMatch_64_5,
+    &shiftgrabMatch_64_6,
+    &shiftgrabMatch_64_7,
+    &shiftgrabMatch_64_8,
+    &shiftgrabMatch_64_9,
+    &shiftgrabMatch_64_10,
+    &shiftgrabMatch_64_11,
+    &shiftgrabMatch_64_12,
+    &shiftgrabMatch_64_13,
+    &shiftgrabMatch_64_14,
+    &shiftgrabMatch_64_15,
+    &shiftgrabMatch_64_16,
+    &shiftgrabMatch_64_17,
+    &shiftgrabMatch_64_18,
+    &shiftgrabMatch_64_19,
+    &shiftgrabMatch_64_20,
+    &shiftgrabMatch_64_21,
+    &shiftgrabMatch_64_22,
+    &shiftgrabMatch_64_23,
+    &shiftgrabMatch_64_24,
+    &shiftgrabMatch_64_25,
+    &shiftgrabMatch_64_26,
+    &shiftgrabMatch_64_27,
+    &shiftgrabMatch_64_28,
+    &shiftgrabMatch_64_29,
+    &shiftgrabMatch_64_30,
+    &shiftgrabMatch_64_31,
+};
+
+#endif /* MULTIACCEL_SHIFTGRAB_H_ */
diff --git a/src/nfa/multishufti.c b/src/nfa/multishufti.c
new file mode 100644
index 00000000..cb85b718
--- /dev/null
+++ b/src/nfa/multishufti.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** \file
+ * \brief Shufti: character class acceleration.
+ *
+ * Utilises the SSSE3 pshufb shuffle instruction
+ */
+
+#include "config.h"
+#include "ue2common.h"
+
+#include "multishufti.h"
+
+#include "multiaccel_common.h"
+
+#if !defined(__AVX2__)
+
+#define MATCH_ALGO long_
+#include "multiaccel_long.h"
+#include "multishufti_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO longgrab_
+#include "multiaccel_longgrab.h"
+#include "multishufti_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shift_
+#include "multiaccel_shift.h"
+#include "multishufti_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shiftgrab_
+#include "multiaccel_shiftgrab.h"
+#include "multishufti_sse.h"
+#undef MATCH_ALGO
+
+#define MULTIACCEL_DOUBLE
+
+#define MATCH_ALGO doubleshift_
+#include "multiaccel_doubleshift.h"
+#include "multishufti_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO doubleshiftgrab_
+#include "multiaccel_doubleshiftgrab.h"
+#include "multishufti_sse.h"
+#undef MATCH_ALGO
+
+#undef MULTIACCEL_DOUBLE
+
+#else
+
+#define MATCH_ALGO long_
+#include "multiaccel_long.h"
+#include "multishufti_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO longgrab_
+#include "multiaccel_longgrab.h"
+#include "multishufti_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shift_
+#include "multiaccel_shift.h"
+#include "multishufti_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shiftgrab_
+#include "multiaccel_shiftgrab.h"
+#include "multishufti_avx2.h"
+#undef MATCH_ALGO
+
+#define MULTIACCEL_DOUBLE
+
+#define MATCH_ALGO doubleshift_
+#include "multiaccel_doubleshift.h"
+#include "multishufti_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO doubleshiftgrab_
+#include "multiaccel_doubleshiftgrab.h"
+#include "multishufti_avx2.h"
+#undef MATCH_ALGO
+
+#undef MULTIACCEL_DOUBLE
+
+#endif
diff --git a/src/sidecar/sidecar.h b/src/nfa/multishufti.h
similarity index 56%
rename from src/sidecar/sidecar.h
rename to src/nfa/multishufti.h
index e0206de8..bcccf607 100644
--- a/src/sidecar/sidecar.h
+++ b/src/nfa/multishufti.h
@@ -26,46 +26,42 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SIDECAR_H
-#define SIDECAR_H
+/** \file
+ * \brief Multishufti: multibyte version of Shufti
+ *
+ * Utilises the SSSE3 pshufb shuffle instruction
+ */
+
+#ifndef MULTISHUFTI_H
+#define MULTISHUFTI_H
 
 #include "ue2common.h"
+#include "util/simd_utils.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-struct sidecar;
-struct sidecar_enabled;
-struct sidecar_scratch;
+const u8 *long_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf,
+                          const u8 *buf_end, const u8 run_len);
 
-/*
- * Sidecar is guaranteed to return the first match of a given id. However, in
- * various cases later matches may also be returned, as may matches for disabled
- * ids
- */
-typedef void (*SidecarCallback)(u64a offset, u32 id, void *context);
+const u8 *longgrab_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf,
+                              const u8 *buf_end, const u8 run_len);
 
-void sidecarExec(const struct sidecar *n, const u8 *buffer, size_t len,
-                 struct sidecar_enabled *enabled,
-                 struct sidecar_scratch *sidecar_scratch,
-                 u64a base_offset, SidecarCallback cb, void *context);
+const u8 *shift_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf,
+                           const u8 *buf_end, const u8 run_len);
 
-u32 sidecarScratchSize(const struct sidecar *n);
+const u8 *shiftgrab_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf,
+                               const u8 *buf_end, const u8 run_len);
 
-void sidecarEnabledInit(const struct sidecar *n,
-                        struct sidecar_enabled *enabled);
+const u8 *doubleshift_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf,
+                                 const u8 *buf_end, const u8 run_len,
+                                 const u8 run2_len);
 
-/* Note: sidecar literals need to be reenabled after they match.
- * This is purely because this behaviour is handy for rose.
- * In rose, they always set their roles when fired (never have to postpone due
- * to history) and if cleared their preds are also cleared so a pred would also
- * have to match again before we need to care about them again
- */
-void sidecarEnabledUnion(const struct sidecar *n, struct sidecar_enabled *dest,
-                         const struct sidecar_enabled *src);
-
-#define ID_TERMINATOR (~0U)
+const u8 *doubleshiftgrab_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf,
+                                     const u8 *buf_end, const u8 run_len,
+                                     const u8 run2_len);
 
 #ifdef __cplusplus
 }
diff --git a/src/nfa/multishufti_avx2.h b/src/nfa/multishufti_avx2.h
new file mode 100644
index 00000000..e9980872
--- /dev/null
+++ b/src/nfa/multishufti_avx2.h
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "shufti_common.h"
+
+#include "ue2common.h"
+#include "util/bitutils.h"
+#include "util/simd_utils.h"
+#include "util/simd_utils_ssse3.h"
+
+static really_inline
+const u8 *JOIN(MATCH_ALGO, fwdBlock)(m256 mask_lo, m256 mask_hi, m256 chars,
+                                     const u8 *buf, const m256 low4bits,
+                                     const m256 zeroes, const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                     , const u8 run_len2
+#endif
+                                     ) {
+    u32 z = block(mask_lo, mask_hi, chars, low4bits, zeroes);
+    return (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])(buf, ~z
+#ifdef MULTIACCEL_DOUBLE
+                                                             , run_len2
+#endif
+                                                             );
+}
+
+const u8 *JOIN(MATCH_ALGO, shuftiExec)(m128 mask_lo, m128 mask_hi,
+                                       const u8 *buf,
+                                       const u8 *buf_end, u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                       , u8 run_len2
+#endif
+                                       ) {
+    assert(buf && buf_end);
+    assert(buf < buf_end);
+
+    // Slow path for small cases.
+    if (buf_end - buf < 32) {
+        return shuftiFwdSlow((const u8 *)&mask_lo, (const u8 *)&mask_hi,
+                             buf, buf_end);
+    }
+
+    const m256 zeroes = zeroes256();
+    const m256 low4bits = set32x8(0xf);
+    const m256 wide_mask_lo = set2x128(mask_lo);
+    const m256 wide_mask_hi = set2x128(mask_hi);
+    const u8 *rv;
+
+    size_t min = (size_t)buf % 32;
+    assert(buf_end - buf >= 32);
+
+    // Preconditioning: most of the time our buffer won't be aligned.
+    m256 chars = loadu256(buf);
+    rv = JOIN(MATCH_ALGO, fwdBlock)(wide_mask_lo, wide_mask_hi, chars, buf,
+                                            low4bits, zeroes, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                            , run_len2
+#endif
+                                            );
+    if (rv) {
+        return rv;
+    }
+    buf += (32 - min);
+
+    // Unrolling was here, but it wasn't doing anything but taking up space.
+    // Reroll FTW.
+    const u8 *last_block = buf_end - 32;
+    while (buf < last_block) {
+        m256 lchars = load256(buf);
+        rv = JOIN(MATCH_ALGO, fwdBlock)(wide_mask_lo, wide_mask_hi, lchars, buf,
+                                        low4bits, zeroes, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                        , run_len2
+#endif
+                                        );
+        if (rv) {
+            return rv;
+        }
+        buf += 32;
+    }
+
+    // Use an unaligned load to mop up the last 32 bytes and get an accurate
+    // picture to buf_end.
+    assert(buf <= buf_end && buf >= buf_end - 32);
+    chars = loadu256(buf_end - 32);
+    rv = JOIN(MATCH_ALGO, fwdBlock)(wide_mask_lo, wide_mask_hi, chars, buf_end - 32,
+                                    low4bits, zeroes, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                    , run_len2
+#endif
+                                    );
+    if (rv) {
+        return rv;
+    }
+
+    return buf_end;
+}
diff --git a/src/nfa/multishufti_sse.h b/src/nfa/multishufti_sse.h
new file mode 100644
index 00000000..7ea5946d
--- /dev/null
+++ b/src/nfa/multishufti_sse.h
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "shufti_common.h"
+
+#include "ue2common.h"
+#include "util/bitutils.h"
+#include "util/simd_utils.h"
+#include "util/simd_utils_ssse3.h"
+
+/* Normal SSSE3 shufti */
+
+static really_inline
+const u8 *JOIN(MATCH_ALGO, fwdBlock)(m128 mask_lo, m128 mask_hi, m128 chars,
+                                     const u8 *buf, const m128 low4bits,
+                                     const m128 zeroes, const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                     , const u8 run_len2
+#endif
+                                             ) {
+    // negate first 16 bits
+    u32 z = block(mask_lo, mask_hi, chars, low4bits, zeroes) ^ 0xFFFF;
+    return (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])(buf, z
+#ifdef MULTIACCEL_DOUBLE
+            , run_len2
+#endif
+            );
+}
+
+/*
+ * 16-byte pipeline, for smaller scans
+ */
+static
+const u8 *JOIN(MATCH_ALGO, shuftiPipeline16)(m128 mask_lo, m128 mask_hi,
+                                             const u8 *buf, const u8 *buf_end,
+                                             const m128 low4bits,
+                                             const m128 zeroes, const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                             , const u8 run_len2
+#endif
+                                             ) {
+    const u8* ptr, *last_buf;
+    u32 last_res;
+
+    // pipeline prologue: scan first 16 bytes
+    m128 data = load128(buf);
+    u32 z = block(mask_lo, mask_hi, data, low4bits, zeroes) ^ 0xFFFF;
+    last_buf = buf;
+    last_res = z;
+    buf += 16;
+
+    // now, start the pipeline!
+    assert((size_t)buf % 16 == 0);
+    for (; buf + 15 < buf_end; buf += 16) {
+        // scan more data
+        data = load128(buf);
+        z = block(mask_lo, mask_hi, data, low4bits, zeroes) ^ 0xFFFF;
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                 , run_len2
+#endif
+                 );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_buf = buf;
+        last_res = z;
+    }
+    assert(buf <= buf_end && buf >= buf_end - 16);
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    return NULL;
+}
+
+/*
+ * 32-byte pipeline, for bigger scans
+ */
+static
+const u8 *JOIN(MATCH_ALGO, shuftiPipeline32)(m128 mask_lo, m128 mask_hi,
+                                             const u8 *buf, const u8 *buf_end,
+                                             const m128 low4bits,
+                                             const m128 zeroes, const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                             , const u8 run_len2
+#endif
+                                             ) {
+    const u8* ptr, *last_buf;
+    u32 res;
+
+    // pipeline prologue: scan first 32 bytes
+    m128 data1 = load128(buf);
+    u32 z1 = block(mask_lo, mask_hi, data1, low4bits, zeroes) ^ 0xFFFF;
+    m128 data2 = load128(buf + 16);
+    u32 z2 = block(mask_lo, mask_hi, data2, low4bits, zeroes) ^ 0xFFFF;
+
+    // store the results
+    u32 last_res = z1 | (z2 << 16);
+    last_buf = buf;
+    buf += 32;
+
+
+    // now, start the pipeline!
+    assert((size_t)buf % 16 == 0);
+    for (; buf + 31 < buf_end; buf += 32) {
+        // scan more data
+        data1 = load128(buf);
+        z1 = block(mask_lo, mask_hi, data1, low4bits, zeroes) ^ 0xFFFF;
+        data2 = load128(buf + 16);
+        z2 = block(mask_lo, mask_hi, data2, low4bits, zeroes) ^ 0xFFFF;
+        res = z1 | (z2 << 16);
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                 , run_len2
+#endif
+                 );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_res = res;
+        last_buf = buf;
+    }
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    // if we still have some data left, scan it too
+    for (; buf + 15 < buf_end; buf += 16) {
+        m128 chars = load128(buf);
+        ptr = JOIN(MATCH_ALGO, fwdBlock)(mask_lo, mask_hi, chars, buf,
+                low4bits, zeroes, run_len
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+    }
+    assert(buf <= buf_end && buf >= buf_end - 16);
+
+    return NULL;
+}
+
+const u8 *JOIN(MATCH_ALGO, shuftiExec)(m128 mask_lo, m128 mask_hi,
+                                       const u8 *buf,
+                                       const u8 *buf_end, u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                       , u8 run_len2
+#endif
+                                               ) {
+    assert(buf && buf_end);
+    assert(buf < buf_end);
+
+    // Slow path for small cases.
+    if (buf_end - buf < 16) {
+        return shuftiFwdSlow((const u8 *)&mask_lo, (const u8 *)&mask_hi,
+                buf, buf_end);
+    }
+
+    const m128 zeroes = zeroes128();
+    const m128 low4bits = _mm_set1_epi8(0xf);
+    const u8 *rv;
+
+    size_t min = (size_t)buf % 16;
+    assert(buf_end - buf >= 16);
+
+    // Preconditioning: most of the time our buffer won't be aligned.
+    m128 chars = loadu128(buf);
+    rv = JOIN(MATCH_ALGO, fwdBlock)(mask_lo, mask_hi, chars, buf,
+            low4bits, zeroes, run_len
+#ifdef MULTIACCEL_DOUBLE
+            , run_len2
+#endif
+            );
+    if (rv) {
+        return rv;
+    }
+    buf += (16 - min);
+
+    // if we have enough data, run bigger pipeline; otherwise run smaller one
+    if (buf_end - buf >= 128) {
+        rv = JOIN(MATCH_ALGO, shuftiPipeline32)(mask_lo, mask_hi,
+                buf, buf_end, low4bits, zeroes, run_len
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                );
+        if (unlikely(rv)) {
+            return rv;
+        }
+    } else if (buf_end - buf >= 16){
+        rv = JOIN(MATCH_ALGO, shuftiPipeline16)(mask_lo, mask_hi,
+                buf, buf_end, low4bits, zeroes, run_len
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                );
+        if (unlikely(rv)) {
+            return rv;
+        }
+    }
+
+    // Use an unaligned load to mop up the last 16 bytes and get an accurate
+    // picture to buf_end.
+    chars = loadu128(buf_end - 16);
+    rv = JOIN(MATCH_ALGO, fwdBlock)(mask_lo, mask_hi, chars,
+            buf_end - 16, low4bits, zeroes, run_len
+#ifdef MULTIACCEL_DOUBLE
+            , run_len2
+#endif
+            );
+    if (rv) {
+        return rv;
+    }
+
+    return buf_end;
+}
diff --git a/src/nfa/multitruffle.c b/src/nfa/multitruffle.c
new file mode 100644
index 00000000..3af6394a
--- /dev/null
+++ b/src/nfa/multitruffle.c
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ue2common.h"
+
+#include "multitruffle.h"
+#include "util/bitutils.h"
+#include "util/simd_utils.h"
+#include "util/simd_utils_ssse3.h"
+
+#include "multiaccel_common.h"
+
+#if !defined(__AVX2__)
+
+#define MATCH_ALGO long_
+#include "multiaccel_long.h"
+#include "multitruffle_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO longgrab_
+#include "multiaccel_longgrab.h"
+#include "multitruffle_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shift_
+#include "multiaccel_shift.h"
+#include "multitruffle_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shiftgrab_
+#include "multiaccel_shiftgrab.h"
+#include "multitruffle_sse.h"
+#undef MATCH_ALGO
+
+#define MULTIACCEL_DOUBLE
+
+#define MATCH_ALGO doubleshift_
+#include "multiaccel_doubleshift.h"
+#include "multitruffle_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO doubleshiftgrab_
+#include "multiaccel_doubleshiftgrab.h"
+#include "multitruffle_sse.h"
+#undef MATCH_ALGO
+
+#undef MULTIACCEL_DOUBLE
+
+#else
+
+#define MATCH_ALGO long_
+#include "multiaccel_long.h"
+#include "multitruffle_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO longgrab_
+#include "multiaccel_longgrab.h"
+#include "multitruffle_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shift_
+#include "multiaccel_shift.h"
+#include "multitruffle_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shiftgrab_
+#include "multiaccel_shiftgrab.h"
+#include "multitruffle_avx2.h"
+#undef MATCH_ALGO
+
+#define MULTIACCEL_DOUBLE
+
+#define MATCH_ALGO doubleshift_
+#include "multiaccel_doubleshift.h"
+#include "multitruffle_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO doubleshiftgrab_
+#include "multiaccel_doubleshiftgrab.h"
+#include "multitruffle_avx2.h"
+#undef MATCH_ALGO
+
+#undef MULTIACCEL_DOUBLE
+
+#endif
diff --git a/src/nfa/multitruffle.h b/src/nfa/multitruffle.h
new file mode 100644
index 00000000..8703b5ca
--- /dev/null
+++ b/src/nfa/multitruffle.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTITRUFFLE_H
+#define MULTITRUFFLE_H
+
+/** \file
+ * \brief Multitruffle: multibyte version of Truffle.
+ *
+ * Utilises the SSSE3 pshufb shuffle instruction
+ */
+
+#include "util/simd_types.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+const u8 *long_truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset,
+                           const u8 *buf, const u8 *buf_end, const u8 run_len);
+
+const u8 *longgrab_truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset,
+                               const u8 *buf, const u8 *buf_end, const u8 run_len);
+
+const u8 *shift_truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset,
+                            const u8 *buf, const u8 *buf_end, const u8 run_len);
+
+const u8 *shiftgrab_truffleExec(m128 shuf_mask_lo_highclear,
+                                m128 shuf_mask_lo_highset, const u8 *buf,
+                                const u8 *buf_end, const u8 run_len);
+
+const u8 *doubleshift_truffleExec(m128 shuf_mask_lo_highclear,
+                                  m128 shuf_mask_lo_highset, const u8 *buf,
+                                  const u8 *buf_end, const u8 run_len,
+                                  const u8 run2_len);
+
+const u8 *doubleshiftgrab_truffleExec(m128 shuf_mask_lo_highclear,
+                                      m128 shuf_mask_lo_highset, const u8 *buf,
+                                      const u8 *buf_end, const u8 run_len,
+                                      const u8 run2_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* MULTITRUFFLE_H */
diff --git a/src/nfa/multitruffle_avx2.h b/src/nfa/multitruffle_avx2.h
new file mode 100644
index 00000000..e52db5fc
--- /dev/null
+++ b/src/nfa/multitruffle_avx2.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Matches a byte in a charclass using three shuffles
+ */
+
+#include "config.h"
+#include "ue2common.h"
+#include "multiaccel_common.h"
+
+/*
+ * include "block" function
+ */
+#include "truffle_common.h"
+
+/*
+ * single-byte truffle fwd match function, should only be defined when not
+ * compiling multiaccel
+ */
+static really_inline
+const u8 *JOIN(MATCH_ALGO, fwdBlock)(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset,
+                                     m256 v, const u8 *buf, const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                     , const u8 run_len2
+#endif
+                                     ) {
+    u64a z = (u64a) block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v);
+    return (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])(buf, z ^ 0xFFFFFFFF
+#ifdef MULTIACCEL_DOUBLE
+                                                             , run_len2
+#endif
+                                                             );
+}
+
+const u8 *JOIN(MATCH_ALGO, truffleExec)(m128 shuf_mask_lo_highclear,
+                                        m128 shuf_mask_lo_highset,
+                                        const u8 *buf, const u8 *buf_end, const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                        , const u8 run_len2
+#endif
+                                        ) {
+    DEBUG_PRINTF("run_len %zu\n", buf_end - buf);
+    const m256 wide_clear = set2x128(shuf_mask_lo_highclear);
+    const m256 wide_set = set2x128(shuf_mask_lo_highset);
+
+    assert(buf && buf_end);
+    assert(buf < buf_end);
+    const u8 *rv;
+
+    if (buf_end - buf < 32) {
+        return truffleMini(wide_clear, wide_set, buf, buf_end);
+    }
+
+    size_t min = (size_t)buf % 32;
+    assert(buf_end - buf >= 32);
+
+    // Preconditioning: most of the time our buffer won't be aligned.
+    m256 chars = loadu256(buf);
+    rv = JOIN(MATCH_ALGO, fwdBlock)(wide_clear, wide_set, chars, buf, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                    , run_len2
+#endif
+                                    );
+    if (rv) {
+        return rv;
+    }
+    buf += (32 - min);
+
+    const u8 *last_block = buf_end - 32;
+    while (buf < last_block) {
+        m256 lchars = load256(buf);
+        rv = JOIN(MATCH_ALGO, fwdBlock)(wide_clear, wide_set, lchars,
+                                        buf, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                        , run_len2
+#endif
+                                        );
+        if (rv) {
+            return rv;
+        }
+        buf += 32;
+    }
+
+    // Use an unaligned load to mop up the last 32 bytes and get an accurate
+    // picture to buf_end.
+    assert(buf <= buf_end && buf >= buf_end - 32);
+    chars = loadu256(buf_end - 32);
+    rv = JOIN(MATCH_ALGO, fwdBlock)(wide_clear, wide_set, chars,
+                                    buf_end - 32, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                    , run_len2
+#endif
+                                    );
+    if (rv) {
+        return rv;
+    }
+
+    return buf_end;
+}
diff --git a/src/nfa/multitruffle_sse.h b/src/nfa/multitruffle_sse.h
new file mode 100644
index 00000000..b287e4fc
--- /dev/null
+++ b/src/nfa/multitruffle_sse.h
@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ue2common.h"
+#include "multiaccel_common.h"
+
+/*
+ * include "block" function
+ */
+#include "truffle_common.h"
+
+/*
+ * single-byte truffle fwd match function, should only be defined when not
+ * compiling multiaccel
+ */
+
+static really_inline
+const u8 *JOIN(MATCH_ALGO, fwdBlock)(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset,
+                                     m128 v, const u8 *buf, const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                     , const u8 run_len2
+#endif
+                                     ) {
+    u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v) ^ 0xFFFF;
+    return (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])(buf, z
+#ifdef MULTIACCEL_DOUBLE
+                                                             , run_len2
+#endif
+            );
+}
+
+/*
+ * 16-byte pipeline, for smaller scans
+ */
+static
+const u8 *JOIN(MATCH_ALGO, trufflePipeline16)(m128 shuf_mask_lo_highclear,
+                                              m128 shuf_mask_lo_highset,
+                                              const u8 *buf, const u8 *buf_end,
+                                              const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                              , const u8 run_len2
+#endif
+                                              ) {
+    const u8* ptr, *last_buf;
+    u32 last_res;
+
+    // pipeline prologue: scan first 16 bytes
+    m128 data = load128(buf);
+    u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data) ^ 0xFFFF;
+    last_buf = buf;
+    last_res = z;
+    buf += 16;
+
+    // now, start the pipeline!
+    assert((size_t)buf % 16 == 0);
+    for (; buf + 15 < buf_end; buf += 16) {
+        // scan more data
+        data = load128(buf);
+        z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data) ^ 0xFFFF;
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                 , run_len2
+#endif
+                 );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_buf = buf;
+        last_res = z;
+    }
+    assert(buf <= buf_end && buf >= buf_end - 16);
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    return NULL;
+}
+
+/*
+ * 32-byte pipeline, for bigger scans
+ */
+static
+const u8 *JOIN(MATCH_ALGO, trufflePipeline32)(m128 shuf_mask_lo_highclear,
+                                              m128 shuf_mask_lo_highset,
+                                              const u8 *buf, const u8 *buf_end,
+                                              const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                              , const u8 run_len2
+#endif
+                                              ) {
+    const u8* ptr, *last_buf;
+    u32 res;
+
+    // pipeline prologue: scan first 32 bytes
+    m128 data1 = load128(buf);
+    u32 z1 = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data1) ^ 0xFFFF;
+    m128 data2 = load128(buf + 16);
+    u32 z2 = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data2) ^ 0xFFFF;
+
+    // store the results
+    u32 last_res = z1 | (z2 << 16);
+    last_buf = buf;
+    buf += 32;
+
+
+    // now, start the pipeline!
+    assert((size_t)buf % 16 == 0);
+    for (; buf + 31 < buf_end; buf += 32) {
+        // scan more data
+        data1 = load128(buf);
+        z1 = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data1) ^ 0xFFFF;
+        data2 = load128(buf + 16);
+        z2 = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data2) ^ 0xFFFF;
+        res = z1 | (z2 << 16);
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                 , run_len2
+#endif
+                 );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_res = res;
+        last_buf = buf;
+    }
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    // if we still have some data left, scan it too
+    for (; buf + 15 < buf_end; buf += 16) {
+        m128 chars = load128(buf);
+        ptr = JOIN(MATCH_ALGO, fwdBlock)(shuf_mask_lo_highclear, shuf_mask_lo_highset,
+                                         chars, buf, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                         , run_len2
+#endif
+                                         );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+    }
+    assert(buf <= buf_end && buf >= buf_end - 16);
+
+    return NULL;
+}
+
+const u8 *JOIN(MATCH_ALGO, truffleExec)(m128 shuf_mask_lo_highclear,
+                                        m128 shuf_mask_lo_highset,
+                                        const u8 *buf, const u8 *buf_end, const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                        , const u8 run_len2
+#endif
+                                                ) {
+    DEBUG_PRINTF("run_len %zu\n", buf_end - buf);
+
+    assert(buf && buf_end);
+    assert(buf < buf_end);
+    const u8 *rv;
+
+    if (buf_end - buf < 16) {
+        return truffleMini(shuf_mask_lo_highclear, shuf_mask_lo_highset, buf, buf_end);
+    }
+
+    size_t min = (size_t)buf % 16;
+    assert(buf_end - buf >= 16);
+
+    // Preconditioning: most of the time our buffer won't be aligned.
+    m128 chars = loadu128(buf);
+    rv = JOIN(MATCH_ALGO, fwdBlock)(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars, buf, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                    , run_len2
+#endif
+                                    );
+    if (rv) {
+        return rv;
+    }
+    buf += (16 - min);
+
+    // if we have enough data, run bigger pipeline; otherwise run smaller one
+    if (buf_end - buf >= 128) {
+        rv = JOIN(MATCH_ALGO, trufflePipeline32)(shuf_mask_lo_highclear, shuf_mask_lo_highset,
+                                                 buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                                 , run_len2
+#endif
+                                                 );
+        if (unlikely(rv)) {
+            return rv;
+        }
+    } else if (buf_end - buf >= 16){
+        rv = JOIN(MATCH_ALGO, trufflePipeline16)(shuf_mask_lo_highclear, shuf_mask_lo_highset,
+                                                 buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                                 , run_len2
+#endif
+                                                 );
+        if (unlikely(rv)) {
+            return rv;
+        }
+    }
+
+    // Use an unaligned load to mop up the last 16 bytes and get an accurate
+    // picture to buf_end.
+    chars = loadu128(buf_end - 16);
+    rv = JOIN(MATCH_ALGO, fwdBlock)(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars,
+                                    buf_end - 16, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                    , run_len2
+#endif
+                                    );
+    if (rv) {
+        return rv;
+    }
+
+    return buf_end;
+}
diff --git a/src/sidecar/sidecar_dump.cpp b/src/nfa/multivermicelli.c
similarity index 50%
rename from src/sidecar/sidecar_dump.cpp
rename to src/nfa/multivermicelli.c
index dfcf4dd2..ab6d2cf2 100644
--- a/src/sidecar/sidecar_dump.cpp
+++ b/src/nfa/multivermicelli.c
@@ -27,75 +27,82 @@
  */
 
 #include "config.h"
-
-#include "sidecar_dump.h"
-#include "sidecar_internal.h"
 #include "ue2common.h"
 
-#include <cstdio>
+#include "multivermicelli.h"
+
+#include "multiaccel_common.h"
+
+#if !defined(__AVX2__)
+
+#define MATCH_ALGO long_
+#include "multiaccel_long.h"
+#include "multivermicelli_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO longgrab_
+#include "multiaccel_longgrab.h"
+#include "multivermicelli_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shift_
+#include "multiaccel_shift.h"
+#include "multivermicelli_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shiftgrab_
+#include "multiaccel_shiftgrab.h"
+#include "multivermicelli_sse.h"
+#undef MATCH_ALGO
+
+#define MULTIACCEL_DOUBLE
+
+#define MATCH_ALGO doubleshift_
+#include "multiaccel_doubleshift.h"
+#include "multivermicelli_sse.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO doubleshiftgrab_
+#include "multiaccel_doubleshiftgrab.h"
+#include "multivermicelli_sse.h"
+#undef MATCH_ALGO
+
+#undef MULTIACCEL_DOUBLE
+
+#else
+
+#define MATCH_ALGO long_
+#include "multiaccel_long.h"
+#include "multivermicelli_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO longgrab_
+#include "multiaccel_longgrab.h"
+#include "multivermicelli_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shift_
+#include "multiaccel_shift.h"
+#include "multivermicelli_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO shiftgrab_
+#include "multiaccel_shiftgrab.h"
+#include "multivermicelli_avx2.h"
+#undef MATCH_ALGO
+
+#define MULTIACCEL_DOUBLE
+
+#define MATCH_ALGO doubleshift_
+#include "multiaccel_doubleshift.h"
+#include "multivermicelli_avx2.h"
+#undef MATCH_ALGO
+
+#define MATCH_ALGO doubleshiftgrab_
+#include "multiaccel_doubleshiftgrab.h"
+#include "multivermicelli_avx2.h"
+#undef MATCH_ALGO
+
+#undef MULTIACCEL_DOUBLE
 
-#ifndef DUMP_SUPPORT
-#error No dump support!
 #endif
-
-namespace ue2 {
-
-static
-void dumpSideShuf(const sidecar_S *s, FILE *f) {
-    fprintf(f, "lo:");
-    for (u32 i = 0; i < 16; i++) {
-        fprintf(f, " %02hhx", ((const u8 *)&s->lo)[i]);
-    }
-    fprintf(f, "\n");
-
-    fprintf(f, "hi:");
-    for (u32 i = 0; i < 16; i++) {
-        fprintf(f, " %02hhx", ((const u8 *)&s->hi)[i]);
-    }
-    fprintf(f, "\n");
-
-    const u8 *enables = (const u8 *)sidecar_ids_to_mask_const(s);
-    fprintf(f, "shufti masks per id\n");
-    for (u32 i = 0; i < s->header.id_count; i++) {
-        fprintf(f, "%u: %02hhx\n", i, enables[i]);
-    }
-}
-
-void sidecarDump(const sidecar *s, FILE *f) {
-    const char *type = "?";
-    switch(s->type) {
-    case SIDECAR_8:
-        type = "8";
-        break;
-    case SIDECAR_32:
-        type = "32";
-        break;
-    case SIDECAR_64:
-        type = "64";
-        break;
-    case SIDECAR_128:
-        type = "128";
-        break;
-    case SIDECAR_256:
-        type = "256";
-        break;
-    case SIDECAR_N:
-        type = "N";
-        break;
-    case SIDECAR_S:
-        type = "S";
-        break;
-    default:
-        assert(0);
-    }
-
-    fprintf(f, "Sidecar:           %s\n", type);
-    fprintf(f, "    size:          %u\n", s->size);
-    fprintf(f, "    used bits:     %u\n", s->mask_bit_count);
-    fprintf(f, "    ids:           %u\n", s->id_count);
-    if (s->type == SIDECAR_S) {
-        dumpSideShuf((const sidecar_S *)s, f);
-    }
-}
-
-} // namespace ue2
diff --git a/src/nfa/multivermicelli.h b/src/nfa/multivermicelli.h
new file mode 100644
index 00000000..55f9b1f2
--- /dev/null
+++ b/src/nfa/multivermicelli.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTIVERMICELLI_H_
+#define MULTIVERMICELLI_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+const u8 *long_vermicelliExec(char c, char nocase, const u8 *buf,
+                              const u8 *buf_end, const u8 run_len);
+
+const u8 *longgrab_vermicelliExec(char c, char nocase, const u8 *buf,
+                                  const u8 *buf_end, const u8 run_len);
+
+const u8 *shift_vermicelliExec(char c, char nocase, const u8 *buf,
+                               const u8 *buf_end, const u8 run_len);
+
+const u8 *shiftgrab_vermicelliExec(char c, char nocase, const u8 *buf,
+                                   const u8 *buf_end, const u8 run_len);
+
+const u8 *doubleshift_vermicelliExec(char c, char nocase, const u8 *buf,
+                                     const u8 *buf_end, const u8 run_len,
+                                     const u8 run2_len);
+
+const u8 *doubleshiftgrab_vermicelliExec(char c, char nocase, const u8 *buf,
+                                         const u8 *buf_end, const u8 run_len,
+                                         const u8 run2_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* MULTIVERMICELLI_H_ */
diff --git a/src/nfa/multivermicelli_avx2.h b/src/nfa/multivermicelli_avx2.h
new file mode 100644
index 00000000..9081aa3f
--- /dev/null
+++ b/src/nfa/multivermicelli_avx2.h
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "util/bitutils.h"
+#include "util/simd_utils.h"
+#include "util/unaligned.h"
+
+#include "multiaccel_common.h"
+
+static really_inline
+const u8 *JOIN(MATCH_ALGO, vermUnalignNocase)(m256 chars,
+                                              const u8 *buf,
+                                              const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                              , const u8 run_len2
+#endif
+                                              ) {
+    m256 casemask = set32x8(CASE_CLEAR);
+    const u8 *ptr;
+    m256 data = loadu256(buf);
+    u32 z = movemask256(eq256(chars, and256(casemask, data)));
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+            (buf, z
+#ifdef MULTIACCEL_DOUBLE
+            , run_len2
+#endif
+            );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+    return NULL;
+}
+
+static really_inline
+const u8 *JOIN(MATCH_ALGO, vermUnalign)(m256 chars,
+                                        const u8 *buf,
+                                        const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                        , const u8 run_len2
+#endif
+                                        ) {
+    const u8 *ptr;
+
+    m256 data = loadu256(buf);
+    u32 z = movemask256(eq256(chars, data));
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+            (buf, z
+#ifdef MULTIACCEL_DOUBLE
+            , run_len2
+#endif
+            );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+    return NULL;
+}
+
+/*
+ * 32-byte pipeline
+ */
+static really_inline
+const u8 *JOIN(MATCH_ALGO, vermPipeline)(m256 chars,
+                                         const u8 *buf,
+                                         const u8 *buf_end,
+                                         const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                         , const u8 run_len2
+#endif
+                                         ) {
+    const u8* ptr, *last_buf;
+    u32 last_res;
+
+    // pipeline prologue: scan first 32 bytes
+    m256 data = load256(buf);
+    u32 z = movemask256(eq256(chars, data));
+    last_res = z;
+    last_buf = buf;
+    buf += 32;
+
+    // now, start the pipeline!
+    assert((size_t)buf % 32 == 0);
+    for (; buf + 31 < buf_end; buf += 32) {
+        // scan more data
+        data = load256(buf);
+        z = movemask256(eq256(chars, data));
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_buf = buf;
+        last_res = z;
+    }
+    assert(buf <= buf_end && buf >= buf_end - 32);
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+            , run_len2
+#endif
+            );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    return NULL;
+}
+
+/*
+ * 32-byte caseless pipeline
+ */
+static really_inline
+const u8 *JOIN(MATCH_ALGO, vermPipelineNocase)(m256 chars,
+                                               const u8 *buf,
+                                               const u8 *buf_end,
+                                               const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                               , const u8 run_len2
+#endif
+                                               ) {
+    m256 casemask = set32x8(CASE_CLEAR);
+    const u8* ptr, *last_buf;
+    u32 last_res;
+
+    // pipeline prologue: scan first 32 bytes
+    m256 data = load256(buf);
+    u32 z = movemask256(eq256(chars, and256(casemask, data)));
+    last_res = z;
+    last_buf = buf;
+    buf += 32;
+
+
+    // now, start the pipeline!
+    assert((size_t)buf % 32 == 0);
+    for (; buf + 31 < buf_end; buf += 32) {
+        // scan more data
+        data = load256(buf);
+        z = movemask256(eq256(chars, and256(casemask, data)));
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_buf = buf;
+        last_res = z;
+    }
+    assert(buf <= buf_end && buf >= buf_end - 32);
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+            , run_len2
+#endif
+            );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    return NULL;
+}
+
+const u8 *JOIN(MATCH_ALGO, vermicelliExec)(char c, char nocase,
+                                           const u8 *buf,
+                                           const u8 *buf_end,
+                                           const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                           , const u8 run_len2
+#endif
+                                           ) {
+    DEBUG_PRINTF("verm scan %s\\x%02hhx over %zu bytes\n",
+                 nocase ? "nocase " : "", c, (size_t)(buf_end - buf));
+    assert(buf < buf_end);
+
+    const u8 *ptr;
+
+    // Handle small scans.
+    if (buf_end - buf < 32) {
+        for (; buf < buf_end; buf++) {
+            char cur = (char)*buf;
+            if (nocase) {
+                cur &= CASE_CLEAR;
+            }
+            if (cur == c) {
+                break;
+            }
+        }
+        return buf;
+    }
+
+    m256 chars = set32x8(c); /* nocase already uppercase */
+
+    uintptr_t min = (uintptr_t)buf % 32;
+
+    if (min) {
+        ptr = nocase ? JOIN(MATCH_ALGO, vermUnalignNocase)(chars,
+                buf, run_len
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                ) : JOIN(MATCH_ALGO, vermUnalign)(chars,
+                        buf, run_len
+#ifdef MULTIACCEL_DOUBLE
+                        , run_len2
+#endif
+                        );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        buf += 32 - min;
+    }
+
+    if (buf_end - buf >= 32){
+        ptr = nocase ? JOIN(MATCH_ALGO, vermPipelineNocase)(chars,
+                buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                ) : JOIN(MATCH_ALGO, vermPipeline)(chars,
+                        buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                        , run_len2
+#endif
+                        );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+    }
+
+    // final unaligned scan
+    ptr = nocase ? JOIN(MATCH_ALGO, vermUnalignNocase)(chars,
+            buf_end - 32, run_len
+#ifdef MULTIACCEL_DOUBLE
+            , run_len2
+#endif
+            ) : JOIN(MATCH_ALGO, vermUnalign)(chars,
+                    buf_end - 32, run_len
+#ifdef MULTIACCEL_DOUBLE
+                    , run_len2
+#endif
+                    );
+
+    // run our pipeline
+    return ptr ? ptr : buf_end;
+}
diff --git a/src/nfa/multivermicelli_sse.h b/src/nfa/multivermicelli_sse.h
new file mode 100644
index 00000000..cdacd2c4
--- /dev/null
+++ b/src/nfa/multivermicelli_sse.h
@@ -0,0 +1,452 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "util/bitutils.h"
+#include "util/simd_utils.h"
+#include "util/unaligned.h"
+
+#define VERM_BOUNDARY 16
+#define VERM_TYPE m128
+#define VERM_SET_FN set16x8
+
+#include "multiaccel_common.h"
+
+static really_inline
+const u8 *JOIN(MATCH_ALGO, vermUnalignNocase)(m128 chars,
+                                              const u8 *buf,
+                                              const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                              , const u8 run_len2
+#endif
+                                              ) {
+    m128 casemask = set16x8(CASE_CLEAR);
+    const u8 *ptr;
+    m128 data = loadu128(buf);
+    u32 z = movemask128(eq128(chars, and128(casemask, data)));
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+            (buf, z
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+    return NULL;
+}
+
+static really_inline
+const u8 *JOIN(MATCH_ALGO, vermUnalign)(m128 chars,
+                                        const u8 *buf,
+                                        const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                        , const u8 run_len2
+#endif
+                                        ) {
+    const u8 *ptr;
+
+    m128 data = loadu128(buf);
+    u32 z = movemask128(eq128(chars, data));
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+            (buf, z
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+    return NULL;
+}
+
+/*
+ * 16-byte pipeline, for smaller scans
+ */
+static
+const u8 *JOIN(MATCH_ALGO, vermPipeline16)(m128 chars,
+                                                 const u8 *buf,
+                                                 const u8 *buf_end,
+                                                 const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                                 , const u8 run_len2
+#endif
+                                                 ) {
+    const u8* ptr, *last_buf;
+    u32 last_res;
+
+    // pipeline prologue: scan first 16 bytes
+    m128 data = load128(buf);
+    u32 z = movemask128(eq128(chars, data));
+    last_buf = buf;
+    last_res = z;
+    buf += 16;
+
+    // now, start the pipeline!
+    assert((size_t)buf % 16 == 0);
+    for (; buf + 15 < buf_end; buf += 16) {
+        // scan more data
+        data = load128(buf);
+        z = movemask128(eq128(chars, data));
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                 , run_len2
+#endif
+                 );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_buf = buf;
+        last_res = z;
+    }
+    assert(buf <= buf_end && buf >= buf_end - 16);
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    return NULL;
+}
+
+/*
+ * 16-byte pipeline, for smaller scans
+ */
+static
+const u8 *JOIN(MATCH_ALGO, vermPipeline16Nocase)(m128 chars,
+                                                         const u8 *buf,
+                                                         const u8 *buf_end,
+                                                         const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                                         , const u8 run_len2
+#endif
+                                                         ) {
+    m128 casemask = set16x8(CASE_CLEAR);
+    const u8* ptr, *last_buf;
+    u32 last_res;
+
+    // pipeline prologue: scan first 16 bytes
+    m128 data = load128(buf);
+    u32 z = movemask128(eq128(chars, and128(casemask, data)));
+    last_buf = buf;
+    last_res = z;
+    buf += 16;
+
+    // now, start the pipeline!
+    assert((size_t)buf % 16 == 0);
+    for (; buf + 15 < buf_end; buf += 16) {
+        // scan more data
+        data = load128(buf);
+        z = movemask128(eq128(chars, and128(casemask, data)));
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                 , run_len2
+#endif
+                 );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_buf = buf;
+        last_res = z;
+    }
+    assert(buf <= buf_end && buf >= buf_end - 16);
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    return NULL;
+}
+
+/*
+ * 32-byte pipeline, for bigger scans
+ */
+static
+const u8 *JOIN(MATCH_ALGO, vermPipeline32)(m128 chars,
+                                                   const u8 *buf,
+                                                   const u8 *buf_end,
+                                                   const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                                   , const u8 run_len2
+#endif
+                                                   ) {
+    const u8* ptr, *last_buf;
+    u32 res;
+
+    // pipeline prologue: scan first 32 bytes
+    m128 data1 = load128(buf);
+    u32 z1 = movemask128(eq128(chars, data1));
+    m128 data2 = load128(buf + 16);
+    u32 z2 = movemask128(eq128(chars, data2));
+
+    // store the results
+    u32 last_res = z1 | (z2 << VERM_BOUNDARY);
+    last_buf = buf;
+    buf += 32;
+
+
+    // now, start the pipeline!
+    assert((size_t)buf % 16 == 0);
+    for (; buf + 31 < buf_end; buf += 32) {
+        // scan more data
+        data1 = load128(buf);
+        z1 = movemask128(eq128(chars, data1));
+        data2 = load128(buf + 16);
+        z2 = movemask128(eq128(chars, data2));
+        res = z1 | (z2 << 16);
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                 , run_len2
+#endif
+                 );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_res = res;
+        last_buf = buf;
+    }
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    // if we still have some data left, scan it too
+    if (buf + 15 < buf_end) {
+        return JOIN(MATCH_ALGO, vermPipeline16)(chars, buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                                , run_len2
+#endif
+                                                );
+    }
+    assert(buf <= buf_end && buf >= buf_end - 16);
+
+    return NULL;
+}
+
+/*
+ * 32-byte caseless pipeline, for bigger scans
+ */
+static
+const u8 *JOIN(MATCH_ALGO, vermPipeline32Nocase)(m128 chars,
+                                                         const u8 *buf,
+                                                         const u8 *buf_end,
+                                                         const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                                         , const u8 run_len2
+#endif
+                                                         ) {
+    m128 casemask = set16x8(CASE_CLEAR);
+    const u8* ptr, *last_buf;
+    u32 last_res;
+
+    // pipeline prologue: scan first 32 bytes
+    m128 data1 = load128(buf);
+    u32 z1 = movemask128(eq128(chars, and128(casemask, data1)));
+    m128 data2 = load128(buf + 16);
+    u32 z2 = movemask128(eq128(chars, and128(casemask, data2)));
+    u32 z = z1 | (z2 << VERM_BOUNDARY);
+
+    last_res = z;
+    last_buf = buf;
+    buf += 32;
+
+    // now, start the pipeline!
+    assert((size_t)buf % 16 == 0);
+    for (; buf + 31 < buf_end; buf += 32) {
+        // scan more data
+        data1 = load128(buf);
+        z1 = movemask128(eq128(chars, and128(casemask, data1)));
+        data2 = load128(buf + 16);
+        z2 = movemask128(eq128(chars, and128(casemask, data2)));
+        z = z1 | (z2 << 16);
+
+        // do a comparison on previous result
+        ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+                (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+                 , run_len2
+#endif
+                 );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        last_res = z;
+        last_buf = buf;
+    }
+
+    // epilogue: compare final results
+    ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])
+            (last_buf, last_res
+#ifdef MULTIACCEL_DOUBLE
+             , run_len2
+#endif
+             );
+    if (unlikely(ptr)) {
+        return ptr;
+    }
+
+    // if we still have some data left, scan it too
+    if (buf + 15 < buf_end) {
+        return JOIN(MATCH_ALGO, vermPipeline16Nocase)(chars, buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                                                              , run_len2
+#endif
+                                                              );
+    }
+    assert(buf <= buf_end && buf >= buf_end - 16);
+
+    return NULL;
+}
+
+const u8 *JOIN(MATCH_ALGO, vermicelliExec)(char c, char nocase,
+                                                   const u8 *buf,
+                                                   const u8 *buf_end,
+                                                   const u8 run_len
+#ifdef MULTIACCEL_DOUBLE
+                                                   , const u8 run_len2
+#endif
+                                                   ) {
+    DEBUG_PRINTF("verm scan %s\\x%02hhx over %zu bytes\n",
+                 nocase ? "nocase " : "", c, (size_t)(buf_end - buf));
+    assert(buf < buf_end);
+
+    const u8 *ptr;
+
+    // Handle small scans.
+    if (buf_end - buf < VERM_BOUNDARY) {
+        for (; buf < buf_end; buf++) {
+            char cur = (char)*buf;
+            if (nocase) {
+                cur &= CASE_CLEAR;
+            }
+            if (cur == c) {
+                break;
+            }
+        }
+        return buf;
+    }
+
+    VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */
+
+    uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY;
+
+    if (min) {
+        ptr = nocase ? JOIN(MATCH_ALGO, vermUnalignNocase)(chars,
+                buf, run_len
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                ) : JOIN(MATCH_ALGO, vermUnalign)(chars,
+                        buf, run_len
+#ifdef MULTIACCEL_DOUBLE
+                        , run_len2
+#endif
+                        );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+        buf += VERM_BOUNDARY - min;
+    }
+
+    // if we have enough data, run bigger pipeline; otherwise run smaller one
+    if (buf_end - buf >= 128) {
+        ptr = nocase ? JOIN(MATCH_ALGO, vermPipeline32Nocase)(chars,
+                buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                ) : JOIN(MATCH_ALGO, vermPipeline32)(chars,
+                        buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                        , run_len2
+#endif
+                        );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+    } else if (buf_end - buf >= 16){
+        ptr = nocase ? JOIN(MATCH_ALGO, vermPipeline16Nocase)(chars,
+                buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                , run_len2
+#endif
+                ) : JOIN(MATCH_ALGO, vermPipeline16)(chars,
+                        buf, buf_end, run_len
+#ifdef MULTIACCEL_DOUBLE
+                        , run_len2
+#endif
+                        );
+        if (unlikely(ptr)) {
+            return ptr;
+        }
+    }
+
+    // final unaligned scan
+    ptr = nocase ? JOIN(MATCH_ALGO, vermUnalignNocase)(chars,
+            buf_end - VERM_BOUNDARY, run_len
+#ifdef MULTIACCEL_DOUBLE
+            , run_len2
+#endif
+            ) : JOIN(MATCH_ALGO, vermUnalign)(chars,
+                    buf_end - VERM_BOUNDARY, run_len
+#ifdef MULTIACCEL_DOUBLE
+                    , run_len2
+#endif
+                    );
+
+    // run our pipeline
+    return ptr ? ptr : buf_end;
+}
diff --git a/src/nfa/nfa_api.h b/src/nfa/nfa_api.h
index 25654990..84f5c4a0 100644
--- a/src/nfa/nfa_api.h
+++ b/src/nfa/nfa_api.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -44,7 +44,6 @@ extern "C"
 #include "callback.h"
 #include "ue2common.h"
 
-struct hs_scratch;
 struct mq;
 struct NFA;
 
@@ -189,7 +188,8 @@ char nfaInAcceptState(const struct NFA *nfa, ReportID report, struct mq *q);
  *        be monotonically increasing. If not all the data was processed during
  *        the call, the queue is updated to reflect the remaining work.
  * @param report we are interested in, if set at the end of the scan returns
- *        @ref MO_MATCHES_PENDING
+ *        @ref MO_MATCHES_PENDING. If no report is desired, MO_INVALID_IDX should
+ *        be passed in.
  * @return @ref MO_ALIVE if the nfa is still active with no matches pending,
  *         and @ref MO_MATCHES_PENDING if there are matches pending, 0 if not
  *         alive
@@ -211,16 +211,12 @@ char nfaQueueExecRose(const struct NFA *nfa, struct mq *q, ReportID report);
  * @param buflen length of buf
  * @param hbuf history buf
  * @param hlen length of hbuf
- * @param scratch scratch
  * @param callback the callback to call for each match raised
  * @param context context pointer passed to each callback
- *
- * Note: is NOT reentrant
  */
 char nfaBlockExecReverse(const struct NFA *nfa, u64a offset, const u8 *buf,
                          size_t buflen, const u8 *hbuf, size_t hlen,
-                         struct hs_scratch *scratch, NfaCallback callback,
-                         void *context);
+                         NfaCallback callback, void *context);
 
 /**
  * Check whether the given NFA's state indicates that it is in one or more
@@ -235,6 +231,9 @@ char nfaBlockExecReverse(const struct NFA *nfa, u64a offset, const u8 *buf,
  * @param callback the callback to call for each match raised
  * @param som_cb the callback to call for each match raised (Haig)
  * @param context context pointer passed to each callback
+ *
+ * @return @ref MO_HALT_MATCHING if the user instructed us to halt, otherwise
+ *         @ref MO_CONTINUE_MATCHING.
  */
 char nfaCheckFinalState(const struct NFA *nfa, const char *state,
                         const char *streamState, u64a offset,
diff --git a/src/nfa/nfa_api_dispatch.c b/src/nfa/nfa_api_dispatch.c
index 0c765b36..fb27e4eb 100644
--- a/src/nfa/nfa_api_dispatch.c
+++ b/src/nfa/nfa_api_dispatch.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -332,13 +332,12 @@ char nfaQueueExecRose(const struct NFA *nfa, struct mq *q, ReportID r) {
 
 char nfaBlockExecReverse(const struct NFA *nfa, u64a offset, const u8 *buf,
                          size_t buflen, const u8 *hbuf, size_t hlen,
-                         struct hs_scratch *scratch, NfaCallback callback,
-                         void *context) {
+                         NfaCallback callback, void *context) {
     assert(nfa);
     assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa)));
 
     DISPATCH_BY_NFA_TYPE(_B_Reverse(nfa, offset, buf, buflen, hbuf, hlen,
-                                    scratch, callback, context));
+                                    callback, context));
     return 0;
 }
 
diff --git a/src/nfa/nfa_api_queue.h b/src/nfa/nfa_api_queue.h
index 59c18fca..1373425d 100644
--- a/src/nfa/nfa_api_queue.h
+++ b/src/nfa/nfa_api_queue.h
@@ -91,7 +91,6 @@ struct mq {
                         * history buffer; (logically) immediately before the
                         * main buffer */
     size_t hlength; /**< length of the history buffer */
-    struct hs_scratch *scratch; /**< global scratch space */
     char report_current; /**<
                           * report_current matches at starting offset through
                           * callback. If true, the queue must be located at a
diff --git a/src/nfa/nfa_internal.h b/src/nfa/nfa_internal.h
index e13482b5..089e9683 100644
--- a/src/nfa/nfa_internal.h
+++ b/src/nfa/nfa_internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -245,14 +245,14 @@ int isMultiTopType(u8 t) {
 /* Use for functions that return an integer. */
 #define NFA_API_NO_IMPL(...)                                                   \
     ({                                                                         \
-        assert("not implemented for this engine!");                            \
+        assert(!"not implemented for this engine!");                            \
         0; /* return value, for places that need it */                         \
     })
 
 /* Use for _zombie_status functions. */
 #define NFA_API_ZOMBIE_NO_IMPL(...)                                            \
     ({                                                                         \
-        assert("not implemented for this engine!");                            \
+        assert(!"not implemented for this engine!");                            \
         NFA_ZOMBIE_NO;                                                         \
     })
 
diff --git a/src/nfa/nfa_kind.h b/src/nfa/nfa_kind.h
index f13e3770..46d0bc4c 100644
--- a/src/nfa/nfa_kind.h
+++ b/src/nfa/nfa_kind.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,6 +26,12 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+/**
+ * \file
+ * \brief Data structures and helper functions used to describe the purpose of
+ * a particular NFA engine at build time.
+ */
+
 #ifndef NFA_KIND_H
 #define NFA_KIND_H
 
@@ -39,17 +45,53 @@ enum nfa_kind {
     NFA_INFIX,  //!< rose infix
     NFA_SUFFIX, //!< rose suffix
     NFA_OUTFIX,  //!< "outfix" nfa not triggered by external events
+    NFA_OUTFIX_RAW, //!< "outfix", but with unmanaged reports
     NFA_REV_PREFIX, //! reverse running prefixes (for som)
 };
 
-static UNUSED
+/** \brief True if this kind of engine is triggered by a top event. */
+inline
 bool is_triggered(enum nfa_kind k) {
-    return k == NFA_INFIX || k == NFA_SUFFIX || k == NFA_REV_PREFIX;
+    switch (k) {
+    case NFA_INFIX:
+    case NFA_SUFFIX:
+    case NFA_REV_PREFIX:
+        return true;
+    default:
+        return false;
+    }
 }
 
-static UNUSED
+/**
+ * \brief True if this kind of engine generates callback events when it
+ * enters accept states.
+ */
+inline
 bool generates_callbacks(enum nfa_kind k) {
-    return k == NFA_SUFFIX || k == NFA_OUTFIX || k == NFA_REV_PREFIX;
+    switch (k) {
+    case NFA_SUFFIX:
+    case NFA_OUTFIX:
+    case NFA_OUTFIX_RAW:
+    case NFA_REV_PREFIX:
+        return true;
+    default:
+        return false;
+    }
+}
+
+/**
+ * \brief True if this kind of engine has reports that are managed by the \ref
+ * ReportManager.
+ */
+inline
+bool has_managed_reports(enum nfa_kind k) {
+    switch (k) {
+    case NFA_SUFFIX:
+    case NFA_OUTFIX:
+        return true;
+    default:
+        return false;
+    }
 }
 
 } // namespace ue2
diff --git a/src/nfa/repeat.c b/src/nfa/repeat.c
index c1ff5162..339829a5 100644
--- a/src/nfa/repeat.c
+++ b/src/nfa/repeat.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -882,15 +882,25 @@ enum RepeatMatch repeatHasMatchTrailer(const struct RepeatInfo *info,
     return REPEAT_NOMATCH;
 }
 
+/** \brief True if the given value can be packed into len bytes.  */
+static really_inline
+int fits_in_len_bytes(u64a val, u32 len) {
+    if (len >= 8) {
+        return 1;
+    }
+    return val <= (1ULL << (len * 8));
+}
+
 static really_inline
 void storePackedRelative(char *dest, u64a val, u64a offset, u64a max, u32 len) {
     assert(val <= offset);
-    assert(max < (1ULL << (8 * len)));
+    assert(fits_in_len_bytes(max, len));
     u64a delta = offset - val;
     if (delta >= max) {
         delta = max;
     }
     DEBUG_PRINTF("delta %llu\n", delta);
+    assert(fits_in_len_bytes(delta, len));
     partial_store_u64a(dest, delta, len);
 }
 
@@ -922,6 +932,11 @@ void repeatPackOffset(char *dest, const struct RepeatInfo *info,
                       const union RepeatControl *ctrl, u64a offset) {
     const struct RepeatOffsetControl *xs = &ctrl->offset;
     DEBUG_PRINTF("packing offset %llu [h %u]\n", xs->offset, info->horizon);
+    if (!info->packedCtrlSize) {
+        assert(info->type == REPEAT_ALWAYS);
+        DEBUG_PRINTF("externally guarded .*\n");
+        return;
+    }
     storePackedRelative(dest, xs->offset, offset, info->horizon,
                         info->packedCtrlSize);
 }
@@ -962,6 +977,7 @@ void repeatPackBitmap(char *dest, const struct RepeatInfo *info,
     DEBUG_PRINTF("packing %llu into %u bytes\n", bitmap, info->packedCtrlSize);
 
     // Write out packed bitmap.
+    assert(fits_in_len_bytes(bitmap, info->packedCtrlSize));
     partial_store_u64a(dest, bitmap, info->packedCtrlSize);
 }
 
@@ -1040,6 +1056,9 @@ void repeatPack(char *dest, const struct RepeatInfo *info,
     case REPEAT_TRAILER:
         repeatPackTrailer(dest, info, ctrl, offset);
         break;
+    case REPEAT_ALWAYS:
+        /* nothing to do - no state */
+        break;
     }
 }
 
@@ -1072,7 +1091,13 @@ static
 void repeatUnpackOffset(const char *src, const struct RepeatInfo *info,
                         u64a offset, union RepeatControl *ctrl) {
     struct RepeatOffsetControl *xs = &ctrl->offset;
-    xs->offset = loadPackedRelative(src, offset, info->packedCtrlSize);
+    if (!info->packedCtrlSize) {
+        assert(info->type == REPEAT_ALWAYS);
+        DEBUG_PRINTF("externally guarded .*\n");
+        xs->offset = 0;
+    } else {
+        xs->offset = loadPackedRelative(src, offset, info->packedCtrlSize);
+    }
     DEBUG_PRINTF("unpacking offset %llu [h%u]\n", xs->offset,
                  info->horizon);
 }
@@ -1149,6 +1174,9 @@ void repeatUnpack(const char *src, const struct RepeatInfo *info, u64a offset,
     case REPEAT_TRAILER:
         repeatUnpackTrailer(src, info, offset, ctrl);
         break;
+    case REPEAT_ALWAYS:
+        /* nothing to do - no state */
+        break;
     }
 }
 
@@ -1423,6 +1451,7 @@ void repeatStoreSparseOptimalP(const struct RepeatInfo *info,
     DEBUG_PRINTF("xs->first:%u xs->last:%u patch:%u\n",
                  xs->first, xs->last, patch);
     DEBUG_PRINTF("value:%llu\n", val);
+    assert(fits_in_len_bytes(val, encoding_size));
     partial_store_u64a(ring + encoding_size * idx, val, encoding_size);
     mmbit_set(active, patch_count, idx);
 }
diff --git a/src/nfa/repeat.h b/src/nfa/repeat.h
index 37374d02..d4f84ea0 100644
--- a/src/nfa/repeat.h
+++ b/src/nfa/repeat.h
@@ -135,6 +135,8 @@ u64a repeatLastTop(const struct RepeatInfo *info,
         return repeatLastTopSparseOptimalP(info, ctrl, state);
     case REPEAT_TRAILER:
         return repeatLastTopTrailer(info, ctrl);
+    case REPEAT_ALWAYS:
+        return 0;
     }
 
     DEBUG_PRINTF("bad repeat type %u\n", info->type);
@@ -200,6 +202,8 @@ u64a repeatNextMatch(const struct RepeatInfo *info,
         return repeatNextMatchSparseOptimalP(info, ctrl, state, offset);
     case REPEAT_TRAILER:
         return repeatNextMatchTrailer(info, ctrl, offset);
+    case REPEAT_ALWAYS:
+        return offset + 1;
     }
 
     DEBUG_PRINTF("bad repeat type %u\n", info->type);
@@ -275,6 +279,9 @@ void repeatStore(const struct RepeatInfo *info, union RepeatControl *ctrl,
     case REPEAT_TRAILER:
         repeatStoreTrailer(info, ctrl, offset, is_alive);
         break;
+    case REPEAT_ALWAYS:
+        /* nothing to do - no state */
+        break;
     }
 }
 
@@ -348,6 +355,8 @@ enum RepeatMatch repeatHasMatch(const struct RepeatInfo *info,
         return repeatHasMatchSparseOptimalP(info, ctrl, state, offset);
     case REPEAT_TRAILER:
         return repeatHasMatchTrailer(info, ctrl, offset);
+    case REPEAT_ALWAYS:
+        return REPEAT_MATCH;
     }
 
     assert(0);
diff --git a/src/nfa/repeat_internal.h b/src/nfa/repeat_internal.h
index bf479d1f..9e3f455c 100644
--- a/src/nfa/repeat_internal.h
+++ b/src/nfa/repeat_internal.h
@@ -47,26 +47,26 @@ enum RepeatType {
     /** General mechanism for tracking {N,M} repeats. Stores the first top as
      * an absolute offset, then subsequent tops in the {N,M} range as a ring of
      * relative top indices stored in a multibit. */
-    REPEAT_RING = 0,
+    REPEAT_RING,
 
     /** Used to track {N,} repeats. Uses the \ref RepeatOffsetControl structure,
      * since only the first top encountered needs to be stored. */
-    REPEAT_FIRST = 1,
+    REPEAT_FIRST,
 
     /** Used to track {0,N} repeats. Much like ::REPEAT_FIRST, except that we
      * store the most recent top encountered. */
-    REPEAT_LAST = 2,
+    REPEAT_LAST,
 
     /** Like ::REPEAT_RING, this is also used for {N,M} repeats, but for cases
      * where there is a large difference between N and M, and developed to
      * reduce the state requirements of this case (relative to the RING model).
      * Uses a small ordered array of top indices relative to \ref
      * RepeatRangeControl::offset. */
-    REPEAT_RANGE = 3,
+    REPEAT_RANGE,
 
     /** Used for {N,M} repeats where 0 < M <= 64. Uses the \ref
      * RepeatBitmapControl structure at runtime. */
-    REPEAT_BITMAP = 4,
+    REPEAT_BITMAP,
 
     /** Optimal mechanism for tracking {N,M} repeats when there is a bound on
      * how frequently they can be retriggered.
@@ -78,13 +78,17 @@ enum RepeatType {
      * referencing a table that stores values from f(0, min) to f(repeat, min)
      * eg: repeat = 5, min = 2.  10001 => f(4,2) + f(0,2) = 9.
      * We search the optimal patch size between min and repeat in advance and
-     * use the scheme above to do encoding and decoding to reduce stream state size
-     * */
-    REPEAT_SPARSE_OPTIMAL_P = 5,
+     * use the scheme above to do encoding and decoding to reduce stream state
+     * size. */
+    REPEAT_SPARSE_OPTIMAL_P,
 
-    /** Used for {N,M} repeats where 0 < N < 64. Uses the \ref RepeatTrailerControl
-     * structure at runtime. */
-    REPEAT_TRAILER = 6,
+    /** Used for {N,M} repeats where 0 < N < 64. Uses the
+     * \ref RepeatTrailerControl structure at runtime. */
+    REPEAT_TRAILER,
+
+    /** Degenerate repeat that always returns true. Used by castle for pseudo
+     * [^X]* repeats. */
+    REPEAT_ALWAYS,
 };
 
 /**
@@ -204,6 +208,8 @@ const char *repeatTypeName(u8 type) {
         return "SPARSE_OPTIMAL_P";
     case REPEAT_TRAILER:
         return "TRAILER";
+    case REPEAT_ALWAYS:
+        return "ALWAYS";
     }
     assert(0);
     return "UNKNOWN";
diff --git a/src/nfa/repeatcompile.cpp b/src/nfa/repeatcompile.cpp
index 2f187503..2e1010bb 100644
--- a/src/nfa/repeatcompile.cpp
+++ b/src/nfa/repeatcompile.cpp
@@ -206,6 +206,13 @@ RepeatStateInfo::RepeatStateInfo(enum RepeatType type, const depth &repeatMin,
         packedFieldSizes[1] = repeatMin;
         packedCtrlSize = (packedFieldSizes[0] + packedFieldSizes[1] + 7U) / 8U;
         break;
+    case REPEAT_ALWAYS:
+        assert(repeatMin == 0ULL);
+        assert(repeatMax.is_infinite());
+        stateSize = 0; // everything is in the control block.
+        horizon = 0;
+        packedCtrlSize = 0;
+        break;
     }
     DEBUG_PRINTF("stateSize=%u, packedCtrlSize=%u, horizon=%u\n", stateSize,
                  packedCtrlSize, horizon);
@@ -232,9 +239,14 @@ u32 streamStateSize(enum RepeatType type, const depth &repeatMin,
 }
 
 enum RepeatType chooseRepeatType(const depth &repeatMin, const depth &repeatMax,
-                                 u32 minPeriod, bool is_reset) {
+                                 u32 minPeriod, bool is_reset,
+                                 bool has_external_guard) {
     if (repeatMax.is_infinite()) {
-        return REPEAT_FIRST;
+        if (has_external_guard && !repeatMin) {
+            return REPEAT_ALWAYS;
+        } else {
+            return REPEAT_FIRST;
+        }
     }
 
     if (repeatMin == depth(0) || is_reset) {
diff --git a/src/nfa/repeatcompile.h b/src/nfa/repeatcompile.h
index 2800ccdb..fe9a7106 100644
--- a/src/nfa/repeatcompile.h
+++ b/src/nfa/repeatcompile.h
@@ -68,7 +68,8 @@ struct RepeatStateInfo {
  * type.
  */
 enum RepeatType chooseRepeatType(const depth &repeatMin, const depth &repeatMax,
-                                 u32 minPeriod, bool is_reset);
+                                 u32 minPeriod, bool is_reset,
+                                 bool has_external_guard = false);
 
 u32 calcPackedBytes(u64a val);
 
diff --git a/src/nfa/shufti.c b/src/nfa/shufti.c
index 7d50709c..b1fec488 100644
--- a/src/nfa/shufti.c
+++ b/src/nfa/shufti.c
@@ -38,20 +38,9 @@
 #include "util/simd_utils.h"
 #include "util/unaligned.h"
 
-/** \brief Naive byte-by-byte implementation. */
-static really_inline
-const u8 *shuftiFwdSlow(const u8 *lo, const u8 *hi, const u8 *buf,
-                        const u8 *buf_end) {
-    assert(buf < buf_end);
+#include "shufti_common.h"
 
-    for (; buf < buf_end; ++buf) {
-        u8 c = *buf;
-        if (lo[c & 0xf] & hi[c >> 4]) {
-            break;
-        }
-    }
-    return buf;
-}
+#include "util/simd_utils_ssse3.h"
 
 /** \brief Naive byte-by-byte implementation. */
 static really_inline
@@ -68,54 +57,11 @@ const u8 *shuftiRevSlow(const u8 *lo, const u8 *hi, const u8 *buf,
     return buf_end;
 }
 
-#ifdef DEBUG
-#include <ctype.h>
-
-#define DUMP_MSK(_t)                                \
-static UNUSED                                       \
-void dumpMsk##_t(m##_t msk) {                       \
-    u8 * mskAsU8 = (u8 *)&msk;                      \
-    for (unsigned i = 0; i < sizeof(msk); i++) {    \
-        u8 c = mskAsU8[i];                          \
-        for (int j = 0; j < 8; j++) {               \
-            if ((c >> (7-j)) & 0x1)                 \
-                printf("1");                        \
-            else                                    \
-                printf("0");                        \
-        }                                           \
-        printf(" ");                                \
-    }                                               \
-}                                                   \
-static UNUSED                                       \
-void dumpMsk##_t##AsChars(m##_t msk) {              \
-    u8 * mskAsU8 = (u8 *)&msk;                      \
-    for (unsigned i = 0; i < sizeof(msk); i++) {    \
-        u8 c = mskAsU8[i];                          \
-        if (isprint(c))                             \
-            printf("%c",c);                         \
-        else                                        \
-            printf(".");                            \
-    }                                               \
-}
-
-DUMP_MSK(128)
-#endif
-
-#include "util/simd_utils_ssse3.h"
-
 #if !defined(__AVX2__)
 /* Normal SSSE3 shufti */
 
-#define GET_LO_4(chars) and128(chars, low4bits)
-#define GET_HI_4(chars) rshift2x64(andnot128(low4bits, chars), 4)
-
 static really_inline
-const u8 *firstMatch(const u8 *buf, m128 t, m128 compare) {
-#ifdef DEBUG
-    DEBUG_PRINTF("confirming match in:"); dumpMsk128(t); printf("\n");
-#endif
-
-    u32 z = movemask128(eq128(t, compare));
+const u8 *firstMatch(const u8 *buf, u32 z) {
     if (unlikely(z != 0xffff)) {
         u32 pos = ctz32(~z & 0xffff);
         assert(pos < 16);
@@ -128,19 +74,9 @@ const u8 *firstMatch(const u8 *buf, m128 t, m128 compare) {
 static really_inline
 const u8 *fwdBlock(m128 mask_lo, m128 mask_hi, m128 chars, const u8 *buf,
                    const m128 low4bits, const m128 zeroes) {
-    m128 c_lo  = pshufb(mask_lo, GET_LO_4(chars));
-    m128 c_hi  = pshufb(mask_hi, GET_HI_4(chars));
-    m128 t     = and128(c_lo, c_hi);
+    u32 z = block(mask_lo, mask_hi, chars, low4bits, zeroes);
 
-#ifdef DEBUG
-    DEBUG_PRINTF(" chars: "); dumpMsk128AsChars(chars); printf("\n");
-    DEBUG_PRINTF("  char: "); dumpMsk128(chars);        printf("\n");
-    DEBUG_PRINTF("  c_lo: "); dumpMsk128(c_lo);         printf("\n");
-    DEBUG_PRINTF("  c_hi: "); dumpMsk128(c_hi);         printf("\n");
-    DEBUG_PRINTF("     t: "); dumpMsk128(t);            printf("\n");
-#endif
-
-    return firstMatch(buf, t, zeroes);
+    return firstMatch(buf, z);
 }
 
 const u8 *shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf,
@@ -307,7 +243,8 @@ const u8 *fwdBlock2(m128 mask1_lo, m128 mask1_hi, m128 mask2_lo, m128 mask2_hi,
     DEBUG_PRINTF("    t2: "); dumpMsk128(t2);           printf("\n");
 #endif
 
-    return firstMatch(buf, t2, ones);
+    u32 z = movemask128(eq128(t2, ones));
+    return firstMatch(buf, z);
 }
 
 const u8 *shuftiDoubleExec(m128 mask1_lo, m128 mask1_hi,
@@ -356,20 +293,8 @@ const u8 *shuftiDoubleExec(m128 mask1_lo, m128 mask1_hi,
 
 #else // AVX2 - 256 wide shuftis
 
-#ifdef DEBUG
-DUMP_MSK(256)
-#endif
-
-#define GET_LO_4(chars) and256(chars, low4bits)
-#define GET_HI_4(chars) rshift4x64(andnot256(low4bits, chars), 4)
-
 static really_inline
-const u8 *firstMatch(const u8 *buf, m256 t, m256 compare) {
-#ifdef DEBUG
-    DEBUG_PRINTF("confirming match in:"); dumpMsk256(t); printf("\n");
-#endif
-
-    u32 z = movemask256(eq256(t, compare));
+const u8 *firstMatch(const u8 *buf, u32 z) {
     if (unlikely(z != 0xffffffff)) {
         u32 pos = ctz32(~z);
         assert(pos < 32);
@@ -382,19 +307,9 @@ const u8 *firstMatch(const u8 *buf, m256 t, m256 compare) {
 static really_inline
 const u8 *fwdBlock(m256 mask_lo, m256 mask_hi, m256 chars, const u8 *buf,
                    const m256 low4bits, const m256 zeroes) {
-    m256 c_lo  = vpshufb(mask_lo, GET_LO_4(chars));
-    m256 c_hi  = vpshufb(mask_hi, GET_HI_4(chars));
-    m256 t     = and256(c_lo, c_hi);
+    u32 z = block(mask_lo, mask_hi, chars, low4bits, zeroes);
 
-#ifdef DEBUG
-    DEBUG_PRINTF(" chars: "); dumpMsk256AsChars(chars); printf("\n");
-    DEBUG_PRINTF("  char: "); dumpMsk256(chars);        printf("\n");
-    DEBUG_PRINTF("  c_lo: "); dumpMsk256(c_lo);         printf("\n");
-    DEBUG_PRINTF("  c_hi: "); dumpMsk256(c_hi);         printf("\n");
-    DEBUG_PRINTF("     t: "); dumpMsk256(t);            printf("\n");
-#endif
-
-    return firstMatch(buf, t, zeroes);
+    return firstMatch(buf, z);
 }
 
 /* takes 128 bit masks, but operates on 256 bits of data */
@@ -564,8 +479,9 @@ const u8 *fwdBlock2(m256 mask1_lo, m256 mask1_hi, m256 mask2_lo, m256 mask2_hi,
     DEBUG_PRINTF(" c2_hi: "); dumpMsk256(c2_hi);        printf("\n");
     DEBUG_PRINTF("    t2: "); dumpMsk256(t2);           printf("\n");
 #endif
+    u32 z = movemask256(eq256(t2, ones));
 
-    return firstMatch(buf, t2, ones);
+    return firstMatch(buf, z);
 }
 
 /* takes 128 bit masks, but operates on 256 bits of data */
diff --git a/src/nfa/shufti_common.h b/src/nfa/shufti_common.h
new file mode 100644
index 00000000..9c11f2b9
--- /dev/null
+++ b/src/nfa/shufti_common.h
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SHUFTI_COMMON_H_
+#define SHUFTI_COMMON_H_
+
+#include "ue2common.h"
+
+#include "util/bitutils.h"
+#include "util/simd_utils.h"
+#include "util/unaligned.h"
+#include "util/simd_utils_ssse3.h"
+
+/*
+ * Common stuff for all versions of shufti (single, multi and multidouble)
+ */
+
+/** \brief Naive byte-by-byte implementation. */
+static really_inline
+const u8 *shuftiFwdSlow(const u8 *lo, const u8 *hi, const u8 *buf,
+                        const u8 *buf_end) {
+    assert(buf < buf_end);
+
+    for (; buf < buf_end; ++buf) {
+        u8 c = *buf;
+        if (lo[c & 0xf] & hi[c >> 4]) {
+            break;
+        }
+    }
+    return buf;
+}
+
+#ifdef DEBUG
+#include <ctype.h>
+
+#define DUMP_MSK(_t)                                \
+static UNUSED                                       \
+void dumpMsk##_t(m##_t msk) {                       \
+    u8 * mskAsU8 = (u8 *)&msk;                      \
+    for (unsigned i = 0; i < sizeof(msk); i++) {    \
+        u8 c = mskAsU8[i];                          \
+        for (int j = 0; j < 8; j++) {               \
+            if ((c >> (7-j)) & 0x1)                 \
+                printf("1");                        \
+            else                                    \
+                printf("0");                        \
+        }                                           \
+        printf(" ");                                \
+    }                                               \
+}                                                   \
+static UNUSED                                       \
+void dumpMsk##_t##AsChars(m##_t msk) {              \
+    u8 * mskAsU8 = (u8 *)&msk;                      \
+    for (unsigned i = 0; i < sizeof(msk); i++) {    \
+        u8 c = mskAsU8[i];                          \
+        if (isprint(c))                             \
+            printf("%c",c);                         \
+        else                                        \
+            printf(".");                            \
+    }                                               \
+}
+
+#endif
+
+#if !defined(__AVX2__)
+
+#ifdef DEBUG
+DUMP_MSK(128)
+#endif
+
+#define GET_LO_4(chars) and128(chars, low4bits)
+#define GET_HI_4(chars) rshift2x64(andnot128(low4bits, chars), 4)
+
+static really_inline
+u32 block(m128 mask_lo, m128 mask_hi, m128 chars, const m128 low4bits,
+          const m128 compare) {
+    m128 c_lo  = pshufb(mask_lo, GET_LO_4(chars));
+    m128 c_hi  = pshufb(mask_hi, GET_HI_4(chars));
+    m128 t     = and128(c_lo, c_hi);
+
+#ifdef DEBUG
+    DEBUG_PRINTF(" chars: "); dumpMsk128AsChars(chars); printf("\n");
+    DEBUG_PRINTF("  char: "); dumpMsk128(chars);        printf("\n");
+    DEBUG_PRINTF("  c_lo: "); dumpMsk128(c_lo);         printf("\n");
+    DEBUG_PRINTF("  c_hi: "); dumpMsk128(c_hi);         printf("\n");
+    DEBUG_PRINTF("     t: "); dumpMsk128(t);            printf("\n");
+#endif
+    return movemask128(eq128(t, compare));
+}
+
+#else
+
+#ifdef DEBUG
+DUMP_MSK(256)
+#endif
+
+#define GET_LO_4(chars) and256(chars, low4bits)
+#define GET_HI_4(chars) rshift4x64(andnot256(low4bits, chars), 4)
+
+static really_inline
+u32 block(m256 mask_lo, m256 mask_hi, m256 chars, const m256 low4bits,
+          const m256 compare) {
+    m256 c_lo  = vpshufb(mask_lo, GET_LO_4(chars));
+    m256 c_hi  = vpshufb(mask_hi, GET_HI_4(chars));
+    m256 t = and256(c_lo, c_hi);
+
+#ifdef DEBUG
+    DEBUG_PRINTF(" chars: "); dumpMsk256AsChars(chars); printf("\n");
+    DEBUG_PRINTF("  char: "); dumpMsk256(chars); printf("\n");
+    DEBUG_PRINTF("  c_lo: "); dumpMsk256(c_lo); printf("\n");
+    DEBUG_PRINTF("  c_hi: "); dumpMsk256(c_hi); printf("\n");
+    DEBUG_PRINTF("     t: "); dumpMsk256(t); printf("\n");
+#endif
+
+    return movemask256(eq256(t, compare));
+}
+
+#endif
+
+
+#endif /* SHUFTI_COMMON_H_ */
diff --git a/src/nfa/shufticompile.cpp b/src/nfa/shufticompile.cpp
index 13ec9d0c..217fcee0 100644
--- a/src/nfa/shufticompile.cpp
+++ b/src/nfa/shufticompile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -32,6 +32,7 @@
 #include "shufticompile.h"
 #include "ue2common.h"
 #include "util/charreach.h"
+#include "util/container.h"
 #include "util/ue2_containers.h"
 
 #include <array>
@@ -107,13 +108,35 @@ int shuftiBuildMasks(const CharReach &c, m128 *lo, m128 *hi) {
     return bit_index;
 }
 
-void shuftiBuildDoubleMasks(const CharReach &onechar,
+static
+array<u16, 4> or_array(array<u16, 4> a, const array<u16, 4> &b) {
+    a[0] |= b[0];
+    a[1] |= b[1];
+    a[2] |= b[2];
+    a[3] |= b[3];
+
+    return a;
+}
+
+
+#define MAX_BUCKETS 8
+static
+void set_buckets_from_mask(u16 nibble_mask, u32 bucket,
+                           array<u8, 16> &byte_mask) {
+    assert(bucket < MAX_BUCKETS);
+
+    u32 mask = nibble_mask;
+    while (mask) {
+        u32 n = findAndClearLSB_32(&mask);
+        byte_mask[n]  &= ~(1 << bucket);
+    }
+}
+
+bool shuftiBuildDoubleMasks(const CharReach &onechar,
                             const flat_set<pair<u8, u8>> &twochar,
                             m128 *lo1, m128 *hi1, m128 *lo2, m128 *hi2) {
     DEBUG_PRINTF("unibytes %zu dibytes %zu\n", onechar.size(),
                  twochar.size());
-    assert(onechar.count() + twochar.size() <= 8);
-
     array<u8, 16> lo1_a;
     array<u8, 16> lo2_a;
     array<u8, 16> hi1_a;
@@ -124,52 +147,65 @@ void shuftiBuildDoubleMasks(const CharReach &onechar,
     hi1_a.fill(0xff);
     hi2_a.fill(0xff);
 
-    u32 i = 0;
-
     // two-byte literals
-    for (flat_set<pair<u8, u8>>::const_iterator it = twochar.begin();
-         it != twochar.end(); ++it, i++) {
-        DEBUG_PRINTF("%u: %02hhx %02hhx\n", i, it->first, it->second);
-        u8 b1 = it->first & 0xf;
-        u8 t1 = it->first >> 4;
-        u8 b2 = it->second & 0xf;
-        u8 t2 = it->second >> 4;
-
-        lo1_a[b1] &= ~(1 << i);
-        hi1_a[t1] &= ~(1 << i);
-        lo2_a[b2] &= ~(1 << i);
-        hi2_a[t2] &= ~(1 << i);
+    vector<array<u16, 4>> nibble_masks;
+    for (const auto &p : twochar) {
+        DEBUG_PRINTF("%02hhx %02hhx\n", p.first, p.second);
+        u16 a_lo = 1U << (p.first  & 0xf);
+        u16 a_hi = 1U << (p.first  >> 4);
+        u16 b_lo = 1U << (p.second & 0xf);
+        u16 b_hi = 1U << (p.second >> 4);
+        nibble_masks.push_back({{a_lo, a_hi, b_lo, b_hi}});
     }
 
     // one-byte literals (second byte is a wildcard)
     for (size_t it = onechar.find_first(); it != CharReach::npos;
-         it = onechar.find_next(it), i++) {
-        DEBUG_PRINTF("%u: %02hhx\n", i, (u8)it);
-        u8 b1 = it & 0xf;
-        u8 t1 = it >> 4;
+         it = onechar.find_next(it)) {
+        DEBUG_PRINTF("%02hhx\n", (u8)it);
+        u16 a_lo = 1U << (it & 0xf);
+        u16 a_hi = 1U << (it >> 4);
+        u16 wildcard = 0xffff;
+        nibble_masks.push_back({{a_lo, a_hi, wildcard, wildcard}});
+    }
 
-        lo1_a[b1] &= ~(1 << i);
-        hi1_a[t1] &= ~(1 << i);
-
-        for (int j = 0; j < 16; j++) {
-            lo2_a[j] &= ~(1 << i);
-            hi2_a[j] &= ~(1 << i);
+    // try to merge strings into shared buckets
+    for (u32 i = 0; i < 4; i++) {
+        map<array<u16, 4>, array<u16, 4>> new_masks;
+        for (const auto &a : nibble_masks) {
+            auto key = a;
+            key[i] = 0;
+            if (!contains(new_masks, key)) {
+                new_masks[key] = a;
+            } else {
+                new_masks[key] = or_array(new_masks[key], a);
+            }
         }
+        nibble_masks.clear();
+        for (const auto &e : new_masks) {
+            nibble_masks.push_back(e.second);
+        }
+    }
+
+    if (nibble_masks.size() > MAX_BUCKETS) {
+        DEBUG_PRINTF("too many buckets needed (%zu)\n", nibble_masks.size());
+        return false;
+    }
+
+    u32 i = 0;
+    for (const auto &a : nibble_masks) {
+        set_buckets_from_mask(a[0], i, lo1_a);
+        set_buckets_from_mask(a[1], i, hi1_a);
+        set_buckets_from_mask(a[2], i, lo2_a);
+        set_buckets_from_mask(a[3], i, hi2_a);
+        i++;
     }
 
     memcpy(lo1, lo1_a.data(), sizeof(m128));
     memcpy(lo2, lo2_a.data(), sizeof(m128));
     memcpy(hi1, hi1_a.data(), sizeof(m128));
     memcpy(hi2, hi2_a.data(), sizeof(m128));
-}
 
-void mergeShuftiMask(m128 *lo, const m128 lo_in, u32 lo_bits) {
-    assert(lo_bits <= 8);
-    const u8 *lo_in_p = (const u8 *)&lo_in;
-    u8 *lo_p = (u8 *)lo;
-    for (u32 i = 0; i < 16; i++) {
-        lo_p[i] |= lo_in_p[i] << lo_bits;
-    }
+    return true;
 }
 
 #ifdef DUMP_SUPPORT
diff --git a/src/nfa/shufticompile.h b/src/nfa/shufticompile.h
index b0cc1b1b..59126b0b 100644
--- a/src/nfa/shufticompile.h
+++ b/src/nfa/shufticompile.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -50,12 +50,14 @@ namespace ue2 {
  */
 int shuftiBuildMasks(const CharReach &chars, m128 *lo, m128 *hi);
 
-void shuftiBuildDoubleMasks(const CharReach &onechar,
+/** \brief Double-byte variant
+ *
+ * Returns false if we are unable to build the masks (too many buckets required)
+ */
+bool shuftiBuildDoubleMasks(const CharReach &onechar,
                             const flat_set<std::pair<u8, u8>> &twochar,
                             m128 *lo1, m128 *hi1, m128 *lo2, m128 *hi2);
 
-void mergeShuftiMask(m128 *lo, const m128 lo_in, u32 lo_bits);
-
 #ifdef DUMP_SUPPORT
 
 /**
diff --git a/src/nfa/truffle.c b/src/nfa/truffle.c
index 86dcda63..8863c71a 100644
--- a/src/nfa/truffle.c
+++ b/src/nfa/truffle.c
@@ -37,18 +37,9 @@
 #include "util/simd_utils.h"
 #include "util/simd_utils_ssse3.h"
 
-#define shift128r(a, b) _mm_srli_epi64((a), (b))
+#include "truffle_common.h"
 
-static really_inline
-const u8 *firstMatch(const u8 *buf, u32 z) {
-    if (unlikely(z != 0xffff)) {
-        u32 pos = ctz32(~z & 0xffff);
-        assert(pos < 16);
-        return buf + pos;
-    }
-
-    return NULL; // no match
-}
+#if !defined(__AVX2__)
 
 static really_inline
 const u8 *lastMatch(const u8 *buf, u32 z) {
@@ -61,25 +52,6 @@ const u8 *lastMatch(const u8 *buf, u32 z) {
     return NULL; // no match
 }
 
-static really_inline
-u32 block(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, m128 v) {
-
-    m128 highconst = _mm_set1_epi8(0x80);
-    m128 shuf_mask_hi = _mm_set1_epi64x(0x8040201008040201);
-
-    // and now do the real work
-    m128 shuf1 = pshufb(shuf_mask_lo_highclear, v);
-    m128 t1 = xor128(v, highconst);
-    m128 shuf2 = pshufb(shuf_mask_lo_highset, t1);
-    m128 t2 = andnot128(highconst, shift128r(v, 4));
-    m128 shuf3 = pshufb(shuf_mask_hi, t2);
-    m128 tmp = and128(or128(shuf1, shuf2), shuf3);
-    m128 tmp2 = eq128(tmp, zeroes128());
-    u32 z = movemask128(tmp2);
-
-    return z;
-}
-
 static really_inline
 const u8 *fwdBlock(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset,
                    m128 v, const u8 *buf) {
@@ -94,30 +66,9 @@ const u8 *revBlock(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset,
     return lastMatch(buf, z);
 }
 
-static
-const u8 *truffleMini(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset,
-                       const u8 *buf, const u8 *buf_end) {
-    uintptr_t len = buf_end - buf;
-    assert(len < 16);
-
-    m128 chars = zeroes128();
-    memcpy(&chars, buf, len);
-
-    u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars);
-    // can't be these bytes in z
-    u32 mask = (0xFFFF >> (16 - len)) ^ 0xFFFF;
-    const u8 *rv = firstMatch(buf, z| mask);
-
-    if (rv) {
-        return rv;
-    } else {
-        return buf_end;
-    }
-}
-
 const u8 *truffleExec(m128 shuf_mask_lo_highclear,
-                       m128 shuf_mask_lo_highset,
-                       const u8 *buf, const u8 *buf_end) {
+                      m128 shuf_mask_lo_highset,
+                      const u8 *buf, const u8 *buf_end) {
     DEBUG_PRINTF("len %zu\n", buf_end - buf);
 
     assert(buf && buf_end);
@@ -166,8 +117,8 @@ const u8 *truffleExec(m128 shuf_mask_lo_highclear,
 
 static
 const u8 *truffleRevMini(m128 shuf_mask_lo_highclear,
-                          m128 shuf_mask_lo_highset, const u8 *buf,
-                          const u8 *buf_end) {
+                         m128 shuf_mask_lo_highset, const u8 *buf,
+                         const u8 *buf_end) {
     uintptr_t len = buf_end - buf;
     assert(len < 16);
 
@@ -184,11 +135,9 @@ const u8 *truffleRevMini(m128 shuf_mask_lo_highclear,
     return buf - 1;
 }
 
-
 const u8 *rtruffleExec(m128 shuf_mask_lo_highclear,
                        m128 shuf_mask_lo_highset,
                        const u8 *buf, const u8 *buf_end) {
-
     assert(buf && buf_end);
     assert(buf < buf_end);
     const u8 *rv;
@@ -233,4 +182,145 @@ const u8 *rtruffleExec(m128 shuf_mask_lo_highclear,
     return buf - 1;
 }
 
+#else
 
+static really_inline
+const u8 *lastMatch(const u8 *buf, u32 z) {
+    if (unlikely(z != 0xffffffff)) {
+        u32 pos = clz32(~z);
+        assert(pos < 32);
+        return buf + (31 - pos);
+    }
+
+    return NULL; // no match
+}
+
+static really_inline
+const u8 *fwdBlock(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset,
+                   m256 v, const u8 *buf) {
+    u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v);
+    return firstMatch(buf, z);
+}
+
+static really_inline
+const u8 *revBlock(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset,
+                   m256 v, const u8 *buf) {
+    u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v);
+    return lastMatch(buf, z);
+}
+
+const u8 *truffleExec(m128 shuf_mask_lo_highclear,
+                      m128 shuf_mask_lo_highset,
+                      const u8 *buf, const u8 *buf_end) {
+    DEBUG_PRINTF("len %zu\n", buf_end - buf);
+    const m256 wide_clear = set2x128(shuf_mask_lo_highclear);
+    const m256 wide_set = set2x128(shuf_mask_lo_highset);
+
+    assert(buf && buf_end);
+    assert(buf < buf_end);
+    const u8 *rv;
+
+    if (buf_end - buf < 32) {
+        return truffleMini(wide_clear, wide_set, buf, buf_end);
+    }
+
+    size_t min = (size_t)buf % 32;
+    assert(buf_end - buf >= 32);
+
+    // Preconditioning: most of the time our buffer won't be aligned.
+    m256 chars = loadu256(buf);
+    rv = fwdBlock(wide_clear, wide_set, chars, buf);
+    if (rv) {
+        return rv;
+    }
+    buf += (32 - min);
+
+    const u8 *last_block = buf_end - 32;
+    while (buf < last_block) {
+        m256 lchars = load256(buf);
+        rv = fwdBlock(wide_clear, wide_set, lchars, buf);
+        if (rv) {
+            return rv;
+        }
+        buf += 32;
+    }
+
+    // Use an unaligned load to mop up the last 32 bytes and get an accurate
+    // picture to buf_end.
+    assert(buf <= buf_end && buf >= buf_end - 32);
+    chars = loadu256(buf_end - 32);
+    rv = fwdBlock(wide_clear, wide_set, chars, buf_end - 32);
+    if (rv) {
+        return rv;
+    }
+    return buf_end;
+}
+
+static
+const u8 *truffleRevMini(m256 shuf_mask_lo_highclear,
+                         m256 shuf_mask_lo_highset, const u8 *buf,
+                         const u8 *buf_end) {
+    uintptr_t len = buf_end - buf;
+    assert(len < 32);
+
+    m256 chars = zeroes256();
+    memcpy(&chars, buf, len);
+
+    u32 mask = (0xFFFFFFFF >> (32 - len)) ^ 0xFFFFFFFF;
+    u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars);
+    const u8 *rv = lastMatch(buf, z | mask);
+
+    if (rv) {
+        return rv;
+    }
+    return buf - 1;
+}
+
+
+const u8 *rtruffleExec(m128 shuf_mask_lo_highclear,
+                       m128 shuf_mask_lo_highset,
+                       const u8 *buf, const u8 *buf_end) {
+    const m256 wide_clear = set2x128(shuf_mask_lo_highclear);
+    const m256 wide_set = set2x128(shuf_mask_lo_highset);
+    assert(buf && buf_end);
+    assert(buf < buf_end);
+    const u8 *rv;
+
+    DEBUG_PRINTF("len %zu\n", buf_end - buf);
+
+    if (buf_end - buf < 32) {
+        return truffleRevMini(wide_clear, wide_set, buf, buf_end);
+    }
+
+    assert(buf_end - buf >= 32);
+
+    // Preconditioning: most of the time our buffer won't be aligned.
+    m256 chars = loadu256(buf_end - 32);
+    rv = revBlock(wide_clear, wide_set, chars,
+                  buf_end - 32);
+    if (rv) {
+        return rv;
+    }
+    buf_end = (const u8 *)((size_t)buf_end & ~((size_t)0x1f));
+
+    const u8 *last_block = buf + 32;
+    while (buf_end > last_block) {
+        buf_end -= 32;
+        m256 lchars = load256(buf_end);
+        rv = revBlock(wide_clear, wide_set, lchars, buf_end);
+        if (rv) {
+            return rv;
+        }
+    }
+
+    // Use an unaligned load to mop up the last 32 bytes and get an accurate
+    // picture to buf_end.
+    chars = loadu256(buf);
+    rv = revBlock(wide_clear, wide_set, chars, buf);
+    if (rv) {
+        return rv;
+    }
+    return buf - 1;
+}
+
+#endif
diff --git a/src/nfa/truffle.h b/src/nfa/truffle.h
index cf5f6346..f67227ad 100644
--- a/src/nfa/truffle.h
+++ b/src/nfa/truffle.h
@@ -26,9 +26,17 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+/** \file
+ * \brief Truffle: fully general character class acceleration.
+ *
+ * Utilises the SSSE3 pshufb or AVX2 vpshufb shuffle instructions
+ */
+
 #ifndef TRUFFLE_H
 #define TRUFFLE_H
+
 #include "util/simd_types.h"
+
 #ifdef __cplusplus
 extern "C"
 {
diff --git a/src/nfa/truffle_common.h b/src/nfa/truffle_common.h
new file mode 100644
index 00000000..122f65c4
--- /dev/null
+++ b/src/nfa/truffle_common.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TRUFFLE_COMMON_H_
+#define TRUFFLE_COMMON_H_
+
+#include "util/bitutils.h"
+#include "util/simd_utils.h"
+#include "util/simd_utils_ssse3.h"
+
+/*
+ * Common stuff for all versions of truffle (single, multi and multidouble)
+ */
+#if !defined(__AVX2__)
+
+static really_inline
+const u8 *firstMatch(const u8 *buf, u32 z) {
+    if (unlikely(z != 0xffff)) {
+        u32 pos = ctz32(~z & 0xffff);
+        assert(pos < 16);
+        return buf + pos;
+    }
+
+    return NULL; // no match
+}
+
+#define shift128r(a, b) _mm_srli_epi64((a), (b))
+static really_inline
+u32 block(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, m128 v) {
+
+    m128 highconst = _mm_set1_epi8(0x80);
+    m128 shuf_mask_hi = _mm_set1_epi64x(0x8040201008040201);
+
+    // and now do the real work
+    m128 shuf1 = pshufb(shuf_mask_lo_highclear, v);
+    m128 t1 = xor128(v, highconst);
+    m128 shuf2 = pshufb(shuf_mask_lo_highset, t1);
+    m128 t2 = andnot128(highconst, shift128r(v, 4));
+    m128 shuf3 = pshufb(shuf_mask_hi, t2);
+    m128 tmp = and128(or128(shuf1, shuf2), shuf3);
+    m128 tmp2 = eq128(tmp, zeroes128());
+    u32 z = movemask128(tmp2);
+
+    return z;
+}
+
+static
+const u8 *truffleMini(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset,
+                       const u8 *buf, const u8 *buf_end) {
+    uintptr_t len = buf_end - buf;
+    assert(len < 16);
+
+    m128 chars = zeroes128();
+    memcpy(&chars, buf, len);
+
+    u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars);
+    // can't be these bytes in z
+    u32 mask = (0xFFFF >> (16 - len)) ^ 0xFFFF;
+    const u8 *rv = firstMatch(buf, z| mask);
+
+    if (rv) {
+        return rv;
+    } else {
+        return buf_end;
+    }
+}
+
+#else
+
+static really_inline
+const u8 *firstMatch(const u8 *buf, u32 z) {
+    if (unlikely(z != 0xffffffff)) {
+        u32 pos = ctz32(~z);
+        assert(pos < 32);
+        return buf + pos;
+    }
+
+    return NULL; // no match
+}
+
+#define shift256r(a, b) _mm256_srli_epi64((a), (b))
+static really_inline
+u32 block(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset, m256 v) {
+
+    m256 highconst = _mm256_set1_epi8(0x80);
+    m256 shuf_mask_hi = _mm256_set1_epi64x(0x8040201008040201);
+
+    // and now do the real work
+    m256 shuf1 = vpshufb(shuf_mask_lo_highclear, v);
+    m256 t1 = xor256(v, highconst);
+    m256 shuf2 = vpshufb(shuf_mask_lo_highset, t1);
+    m256 t2 = andnot256(highconst, shift256r(v, 4));
+    m256 shuf3 = vpshufb(shuf_mask_hi, t2);
+    m256 tmp = and256(or256(shuf1, shuf2), shuf3);
+    m256 tmp2 = eq256(tmp, zeroes256());
+    u32 z = movemask256(tmp2);
+
+    return z;
+}
+
+static
+const u8 *truffleMini(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset,
+                       const u8 *buf, const u8 *buf_end) {
+    uintptr_t len = buf_end - buf;
+    assert(len < 32);
+
+    m256 chars = zeroes256();
+    memcpy(&chars, buf, len);
+
+    u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars);
+    // can't be these bytes in z
+    u32 mask = (0xFFFFFFFF >> (32 - len)) ^ 0xFFFFFFFF;
+    const u8 *rv = firstMatch(buf, z | mask);
+
+    if (rv) {
+        return rv;
+    } else {
+        return buf_end;
+    }
+}
+
+#endif
+
+#endif /* TRUFFLE_COMMON_H_ */
diff --git a/src/nfa/vermicelli.h b/src/nfa/vermicelli.h
index e6957f9f..ba8afcf1 100644
--- a/src/nfa/vermicelli.h
+++ b/src/nfa/vermicelli.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -178,11 +178,66 @@ const u8 *vermicelliDoubleExec(char c1, char c2, char nocase, const u8 *buf,
     }
 
     // Aligned loops from here on in
-    if (nocase) {
-        return dvermSearchAlignedNocase(chars1, chars2, c1, c2, buf, buf_end);
-    } else {
-        return dvermSearchAligned(chars1, chars2, c1, c2, buf, buf_end);
+    const u8 *ptr = nocase ? dvermSearchAlignedNocase(chars1, chars2, c1, c2,
+                                                      buf, buf_end)
+                           : dvermSearchAligned(chars1, chars2, c1, c2, buf,
+                                                buf_end);
+    if (ptr) {
+        return ptr;
     }
+
+    // Tidy up the mess at the end
+    ptr = nocase ? dvermPreconditionNocase(chars1, chars2,
+                                           buf_end - VERM_BOUNDARY)
+                 : dvermPrecondition(chars1, chars2, buf_end - VERM_BOUNDARY);
+    /* buf_end - 1 to be conservative in case last byte is a partial match */
+    return ptr ? ptr :  buf_end - 1;
+
+}
+
+static really_inline
+const u8 *vermicelliDoubleMaskedExec(char c1, char c2, char m1, char m2,
+                                     const u8 *buf, const u8 *buf_end) {
+    DEBUG_PRINTF("double verm scan (\\x%02hhx&\\x%02hhx)(\\x%02hhx&\\x%02hhx) "
+                 "over %zu bytes\n", c1, m1, c2, m2, (size_t)(buf_end - buf));
+    assert(buf < buf_end);
+    assert((buf_end - buf) >= VERM_BOUNDARY);
+
+    uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY;
+    VERM_TYPE chars1 = VERM_SET_FN(c1);
+    VERM_TYPE chars2 = VERM_SET_FN(c2);
+    VERM_TYPE mask1 = VERM_SET_FN(m1);
+    VERM_TYPE mask2 = VERM_SET_FN(m2);
+
+    if (min) {
+        // Input isn't aligned, so we need to run one iteration with an
+        // unaligned load, then skip buf forward to the next aligned address.
+        // There's some small overlap here, but we don't mind scanning it twice
+        // if we can do it quickly, do we?
+        const u8 *p = dvermPreconditionMasked(chars1, chars2, mask1, mask2, buf);
+        if (p) {
+            return p;
+        }
+
+        buf += VERM_BOUNDARY - min;
+        if (buf >= buf_end) {
+            return buf_end - 1;
+        }
+    }
+
+    // Aligned loops from here on in
+    const u8 *ptr = dvermSearchAlignedMasked(chars1, chars2, mask1, mask2, c1,
+                                             c2, m1, m2, buf, buf_end);
+    if (ptr) {
+        return ptr;
+    }
+
+    // Tidy up the mess at the end
+    ptr = dvermPreconditionMasked(chars1, chars2, mask1, mask2,
+                                  buf_end - VERM_BOUNDARY);
+    /* buf_end - 1 to be conservative in case last byte is a partial match */
+    return ptr ? ptr : buf_end - 1;
+
 }
 
 // Reverse vermicelli scan. Provides exact semantics and returns (buf - 1) if
diff --git a/src/nfa/vermicelli_sse.h b/src/nfa/vermicelli_sse.h
index 1a041505..1883a44c 100644
--- a/src/nfa/vermicelli_sse.h
+++ b/src/nfa/vermicelli_sse.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -147,7 +147,8 @@ const u8 *dvermSearchAligned(m128 chars1, m128 chars2, u8 c1, u8 c2,
             return buf + pos;
         }
     }
-    return buf;
+
+    return NULL;
 }
 
 static really_inline
@@ -169,7 +170,30 @@ const u8 *dvermSearchAlignedNocase(m128 chars1, m128 chars2, u8 c1, u8 c2,
             return buf + pos;
         }
     }
-    return buf;
+
+    return NULL;
+}
+
+static really_inline
+const u8 *dvermSearchAlignedMasked(m128 chars1, m128 chars2,
+                                   m128 mask1, m128 mask2, u8 c1, u8 c2, u8 m1,
+                                   u8 m2, const u8 *buf, const u8 *buf_end) {
+    assert((size_t)buf % 16 == 0);
+
+    for (; buf + 16 < buf_end; buf += 16) {
+        m128 data = load128(buf);
+        u32 z = movemask128(and128(eq128(chars1, and128(data, mask1)),
+                   shiftRight8Bits(eq128(chars2, and128(data, mask2)))));
+        if ((buf[15] & m1) == c1 && (buf[16] & m2) == c2) {
+            z |= (1 << 15);
+        }
+        if (unlikely(z)) {
+            u32 pos = ctz32(z);
+            return buf + pos;
+        }
+    }
+
+    return NULL;
 }
 
 // returns NULL if not found
@@ -205,6 +229,22 @@ const u8 *dvermPreconditionNocase(m128 chars1, m128 chars2, const u8 *buf) {
     return NULL;
 }
 
+// returns NULL if not found
+static really_inline
+const u8 *dvermPreconditionMasked(m128 chars1, m128 chars2,
+                                  m128 mask1, m128 mask2, const u8 *buf) {
+    m128 data = loadu128(buf); // unaligned
+    u32 z = movemask128(and128(eq128(chars1, and128(data, mask1)),
+               shiftRight8Bits(eq128(chars2, and128(data, mask2)))));
+
+    /* no fixup of the boundary required - the aligned run will pick it up */
+    if (unlikely(z)) {
+        u32 pos = ctz32(z);
+        return buf + pos;
+    }
+    return NULL;
+}
+
 static really_inline
 const u8 *lastMatchOffset(const u8 *buf_end, u32 z) {
     assert(z);
diff --git a/src/nfagraph/ng.cpp b/src/nfagraph/ng.cpp
index 7f866a66..b4b34d74 100644
--- a/src/nfagraph/ng.cpp
+++ b/src/nfagraph/ng.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -130,6 +130,7 @@ bool addComponentSom(NG &ng, NGHolder &g, const NGWrapper &w,
 
     assert(g.kind == NFA_OUTFIX);
     dumpComponent(g, "haig", w.expressionIndex, comp_id, ng.cc.grey);
+    makeReportsSomPass(ng.rm, g);
     auto haig = attemptToBuildHaig(g, som, ng.ssm.somPrecision(), triggers,
                                    ng.cc.grey);
     if (haig) {
@@ -167,6 +168,7 @@ void reduceGraph(NGHolder &g, som_type som, bool utf8,
         changed |= removeEdgeRedundancy(g, som, cc);
         changed |= reduceGraphEquivalences(g, cc);
         changed |= removeRedundancy(g, som);
+        changed |= removeCyclicPathRedundancy(g);
         if (!changed) {
             DEBUG_PRINTF("graph unchanged after pass %u, stopping\n", pass);
             break;
@@ -183,7 +185,6 @@ void reduceGraph(NGHolder &g, som_type som, bool utf8,
         removeEdgeRedundancy(g, som, cc);
     }
 
-    removeCyclicPathRedundancy(g);
     removeCyclicDominated(g, som);
 
     if (!som) {
@@ -402,6 +403,13 @@ bool NG::addGraph(NGWrapper &w) {
 
     dumpDotWrapper(w, "03_early", cc.grey);
 
+    // Perform a reduction pass to merge sibling character classes together.
+    if (cc.grey.performGraphSimplification) {
+        removeRedundancy(w, som);
+    }
+
+    dumpDotWrapper(w, "04_reduced", cc.grey);
+
     // If we've got some literals that span the graph from start to accept, we
     // can split them off into Rose from here.
     if (!som) {
diff --git a/src/nfagraph/ng_depth.h b/src/nfagraph/ng_depth.h
index 38a98a1c..16231ea1 100644
--- a/src/nfagraph/ng_depth.h
+++ b/src/nfagraph/ng_depth.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -64,7 +64,11 @@ struct NFAVertexRevDepth {
 /**
  * \brief Encapsulates min/max depths relative to all of our special vertices.
  */
-struct NFAVertexBidiDepth : NFAVertexDepth, NFAVertexRevDepth {
+struct NFAVertexBidiDepth {
+    DepthMinMax fromStart;
+    DepthMinMax fromStartDotStar;
+    DepthMinMax toAccept;
+    DepthMinMax toAcceptEod;
 };
 
 /**
diff --git a/src/nfagraph/ng_dump.cpp b/src/nfagraph/ng_dump.cpp
index 175082f8..60122cf3 100644
--- a/src/nfagraph/ng_dump.cpp
+++ b/src/nfagraph/ng_dump.cpp
@@ -358,35 +358,38 @@ void dumpSmallWrite(const RoseEngine *rose, const Grey &grey) {
     smwrDumpNFA(smwr, false, grey.dumpPath);
 }
 
-static UNUSED
-const char *irTypeToString(u8 type) {
-#define IR_TYPE_CASE(x) case x: return #x
+static
+const char *reportTypeToString(ReportType type) {
+#define REPORT_TYPE_CASE(x) case x: return #x
     switch (type) {
-        IR_TYPE_CASE(EXTERNAL_CALLBACK);
-        IR_TYPE_CASE(EXTERNAL_CALLBACK_SOM_REL);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_SET);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_SET_IF_UNSET);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_SET_IF_WRITABLE);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_SET_SOM_REV_NFA);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_COPY);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_COPY_IF_WRITABLE);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_MAKE_WRITABLE);
-        IR_TYPE_CASE(EXTERNAL_CALLBACK_SOM_STORED);
-        IR_TYPE_CASE(EXTERNAL_CALLBACK_SOM_ABS);
-        IR_TYPE_CASE(EXTERNAL_CALLBACK_SOM_REV_NFA);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_SET_FROM);
-        IR_TYPE_CASE(INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE);
-        IR_TYPE_CASE(INTERNAL_ROSE_CHAIN);
-    default: return "<unknown>";
+        REPORT_TYPE_CASE(EXTERNAL_CALLBACK);
+        REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_REL);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_IF_UNSET);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_IF_WRITABLE);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_SOM_REV_NFA);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_COPY);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_COPY_IF_WRITABLE);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_MAKE_WRITABLE);
+        REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_STORED);
+        REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_ABS);
+        REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_REV_NFA);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_FROM);
+        REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE);
+        REPORT_TYPE_CASE(INTERNAL_ROSE_CHAIN);
+        REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_PASS);
     }
-#undef IR_TYPE_CASE
+#undef REPORT_TYPE_CASE
+
+    assert(0);
+    return "<unknown>";
 }
 
-static really_inline
-int isReverseNfaReport(const Report &ri) {
-    switch (ri.type) {
+static
+int isReverseNfaReport(const Report &report) {
+    switch (report.type) {
     case INTERNAL_SOM_LOC_SET_SOM_REV_NFA:
     case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET:
     case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE:
@@ -398,9 +401,9 @@ int isReverseNfaReport(const Report &ri) {
     return 0;
 }
 
-static really_inline
-int isSomRelSetReport(const Report &ri) {
-    switch (ri.type) {
+static
+int isSomRelSetReport(const Report &report) {
+    switch (report.type) {
     case INTERNAL_SOM_LOC_SET:
     case INTERNAL_SOM_LOC_SET_IF_UNSET:
     case INTERNAL_SOM_LOC_SET_IF_WRITABLE:
@@ -420,31 +423,34 @@ void dumpReportManager(const ReportManager &rm, const Grey &grey) {
     ss << grey.dumpPath << "internal_reports.txt";
     FILE *f = fopen(ss.str().c_str(), "w");
     const vector<Report> &reports = rm.reports();
-    for (u32 i = 0; i < reports.size(); i++) {
-        const Report &ir = reports[i];
-        fprintf(f, "int %u: %s onmatch: %u", i, irTypeToString(ir.type),
-                ir.onmatch);
+    for (size_t i = 0; i < reports.size(); i++) {
+        const Report &report = reports[i];
+        fprintf(f, "%zu: %s onmatch: %u", i, reportTypeToString(report.type),
+                report.onmatch);
 
-        u32 dkey = rm.getDkey(ir);
+        u32 dkey = rm.getDkey(report);
         if (dkey != MO_INVALID_IDX) {
             fprintf(f, " dkey %u", dkey);
         }
-        if (ir.ekey != MO_INVALID_IDX) {
-            fprintf(f, " ekey %u", ir.ekey);
+        if (report.ekey != INVALID_EKEY) {
+            fprintf(f, " ekey %u", report.ekey);
         }
-        if (ir.hasBounds()) {
+        if (report.hasBounds()) {
             fprintf(f, " hasBounds (minOffset=%llu, maxOffset=%llu, "
                        "minLength=%llu)",
-                    ir.minOffset, ir.maxOffset, ir.minLength);
+                    report.minOffset, report.maxOffset, report.minLength);
         }
-        if (ir.offsetAdjust != 0) {
-            fprintf(f, " offsetAdjust: %d", ir.offsetAdjust);
+        if (report.quashSom) {
+            fprintf(f, " quashSom");
         }
-        if (isReverseNfaReport(ir)) {
-            fprintf(f, " reverse nfa: %u", ir.revNfaIndex);
+        if (report.offsetAdjust != 0) {
+            fprintf(f, " offsetAdjust: %d", report.offsetAdjust);
         }
-        if (isSomRelSetReport(ir)) {
-            fprintf(f, " set, adjust: %lld", ir.somDistance);
+        if (isReverseNfaReport(report)) {
+            fprintf(f, " reverse nfa: %u", report.revNfaIndex);
+        }
+        if (isSomRelSetReport(report)) {
+            fprintf(f, " set, adjust: %lld", report.somDistance);
         }
         fprintf(f, "\n");
     }
diff --git a/src/nfagraph/ng_equivalence.cpp b/src/nfagraph/ng_equivalence.cpp
index 148cad49..b8e5a8d6 100644
--- a/src/nfagraph/ng_equivalence.cpp
+++ b/src/nfagraph/ng_equivalence.cpp
@@ -377,7 +377,7 @@ void partitionGraph(ptr_vector<VertexInfo> &infos, ClassMap &classes,
             work_queue.push(eq_class);
         }
     }
-    DEBUG_PRINTF("partitioned, %lu equivalence classes\n", classinfomap.size());
+    DEBUG_PRINTF("partitioned, %zu equivalence classes\n", classinfomap.size());
 }
 
 // generalized equivalence processing (left and right)
diff --git a/src/nfagraph/ng_expr_info.cpp b/src/nfagraph/ng_expr_info.cpp
index 2afb568b..cfd34ce6 100644
--- a/src/nfagraph/ng_expr_info.cpp
+++ b/src/nfagraph/ng_expr_info.cpp
@@ -94,11 +94,34 @@ void checkVertex(const ReportManager &rm, const NGWrapper &w, NFAVertex v,
     const DepthMinMax &d = depths.at(idx);
 
     for (ReportID report_id : w[v].reports) {
-        const Report &ir = rm.getReport(report_id);
-        assert(ir.type == EXTERNAL_CALLBACK);
-        s32 adjust = ir.offsetAdjust;
-        info.min = min(info.min, d.min + adjust);
-        info.max = max(info.max, d.max + adjust);
+        const Report &report = rm.getReport(report_id);
+        assert(report.type == EXTERNAL_CALLBACK);
+
+        DepthMinMax rd = d;
+
+        // Compute graph width to this report, taking any offset adjustment
+        // into account.
+        rd.min += report.offsetAdjust;
+        rd.max += report.offsetAdjust;
+
+        // A min_length param is a lower bound for match width.
+        if (report.minLength && report.minLength <= depth::max_value()) {
+            depth min_len((u32)report.minLength);
+            rd.min = max(rd.min, min_len);
+            rd.max = max(rd.max, min_len);
+        }
+
+        // A max_offset param is an upper bound for match width.
+        if (report.maxOffset && report.maxOffset <= depth::max_value()) {
+            depth max_offset((u32)report.maxOffset);
+            rd.min = min(rd.min, max_offset);
+            rd.max = min(rd.max, max_offset);
+        }
+
+        DEBUG_PRINTF("vertex %u report %u: %s\n", w[v].index, report_id,
+                      rd.str().c_str());
+
+        info = unionDepthMinMax(info, rd);
     }
 }
 
diff --git a/src/nfagraph/ng_haig.cpp b/src/nfagraph/ng_haig.cpp
index d06083bd..8fe4889d 100644
--- a/src/nfagraph/ng_haig.cpp
+++ b/src/nfagraph/ng_haig.cpp
@@ -69,17 +69,15 @@ struct haig_too_wide {
 
 template<typename stateset>
 static
-void populateInit(const NGHolder &g,
-                  const ue2::unordered_map<NFAVertex, u32> &state_ids,
+void populateInit(const NGHolder &g, const flat_set<NFAVertex> &unused,
                   stateset *init, stateset *initDS,
                   vector<NFAVertex> *v_by_index) {
     DEBUG_PRINTF("graph kind: %u\n", (int)g.kind);
     for (auto v : vertices_range(g)) {
-        u32 v_index = g[v].index;
-        if (state_ids.at(v) == NO_STATE) {
+        if (contains(unused, v)) {
             continue;
         }
-
+        u32 v_index = g[v].index;
         if (is_any_start(v, g)) {
             init->set(v_index);
             if (hasSelfLoop(v, g) || is_triggered(g)) {
@@ -113,20 +111,106 @@ void populateAccepts(const NGHolder &g, StateSet *accept, StateSet *acceptEod) {
     }
 }
 
+template<typename Automaton_Traits>
 class Automaton_Base {
+public:
+    using StateSet = typename Automaton_Traits::StateSet;
+    using StateMap = typename Automaton_Traits::StateMap;
+
 protected:
     Automaton_Base(const NGHolder &graph_in,
-                   const ue2::unordered_map<NFAVertex, u32> &state_ids_in)
-        : graph(graph_in), state_ids(state_ids_in) {
+                   const flat_set<NFAVertex> &unused_in, som_type som,
+                   const vector<vector<CharReach>> &triggers,
+                   bool unordered_som)
+        : graph(graph_in), numStates(num_vertices(graph)), unused(unused_in),
+          init(Automaton_Traits::init_states(numStates)),
+          initDS(Automaton_Traits::init_states(numStates)),
+          squash(Automaton_Traits::init_states(numStates)),
+          accept(Automaton_Traits::init_states(numStates)),
+          acceptEod(Automaton_Traits::init_states(numStates)),
+          toppable(Automaton_Traits::init_states(numStates)),
+          dead(Automaton_Traits::init_states(numStates)) {
         calculateAlphabet(graph, alpha, unalpha, &alphasize);
         assert(alphasize <= ALPHABET_SIZE);
+
+        populateInit(graph, unused, &init, &initDS, &v_by_index);
+        populateAccepts(graph, &accept, &acceptEod);
+
+        start_anchored = DEAD_STATE + 1;
+        if (initDS == init) {
+            start_floating = start_anchored;
+        } else if (initDS.any()) {
+            start_floating = start_anchored + 1;
+        } else {
+            start_floating = DEAD_STATE;
+        }
+
+        cr_by_index = populateCR(graph, v_by_index, alpha);
+
+        if (!unordered_som) {
+            for (const auto &sq : findSquashers(graph, som)) {
+                NFAVertex v = sq.first;
+                u32 vert_id = graph[v].index;
+                squash.set(vert_id);
+                squash_mask[vert_id] = shrinkStateSet(sq.second);
+            }
+        }
+
+        if (is_triggered(graph)) {
+            dynamic_bitset<> temp(numStates);
+            markToppableStarts(graph, unused, false, triggers, &temp);
+            toppable = Automaton_Traits::copy_states(temp, numStates);
+        }
+    }
+
+private:
+    // Convert an NFAStateSet (as used by the squash code) into a StateSet.
+    StateSet shrinkStateSet(const NFAStateSet &in) const {
+        StateSet out = Automaton_Traits::init_states(numStates);
+        for (size_t i = in.find_first(); i != in.npos && i < out.size();
+             i = in.find_next(i)) {
+            out.set(i);
+        }
+        return out;
+    }
+
+    void reports_i(const StateSet &in, bool eod, flat_set<ReportID> &rv) {
+        StateSet acc = in & (eod ? acceptEod : accept);
+        for (size_t i = acc.find_first(); i != StateSet::npos;
+             i = acc.find_next(i)) {
+            NFAVertex v = v_by_index[i];
+            DEBUG_PRINTF("marking report\n");
+            const auto &my_reports = graph[v].reports;
+            rv.insert(my_reports.begin(), my_reports.end());
+        }
     }
 
 public:
+    void transition(const StateSet &in, StateSet *next) {
+        transition_graph(*this, v_by_index, in, next);
+    }
+
+    const vector<StateSet> initial() {
+        vector<StateSet> rv = {init};
+        if (start_floating != DEAD_STATE && start_floating != start_anchored) {
+            rv.push_back(initDS);
+        }
+        return rv;
+    }
+
+    void reports(const StateSet &in, flat_set<ReportID> &rv) {
+        reports_i(in, false, rv);
+    }
+
+    void reportsEod(const StateSet &in, flat_set<ReportID> &rv) {
+        reports_i(in, true, rv);
+    }
+
     static bool canPrune(const flat_set<ReportID> &) { return false; }
 
     const NGHolder &graph;
-    const ue2::unordered_map<NFAVertex, u32> &state_ids;
+    const u32 numStates;
+    const flat_set<NFAVertex> &unused;
 
     array<u16, ALPHABET_SIZE> alpha;
     array<u16, ALPHABET_SIZE> unalpha;
@@ -137,202 +221,68 @@ public:
 
     u16 start_anchored;
     u16 start_floating;
+
+    vector<NFAVertex> v_by_index;
+    vector<CharReach> cr_by_index; /* pre alpha'ed */
+    StateSet init;
+    StateSet initDS;
+    StateSet squash; /* states which allow us to mask out other states */
+    StateSet accept;
+    StateSet acceptEod;
+    StateSet toppable; /* states which are allowed to be on when a top arrives,
+                        * triggered dfas only */
+    map<u32, StateSet> squash_mask;
+    StateSet dead;
 };
 
-class Automaton_Big : public Automaton_Base {
-public:
-    typedef dynamic_bitset<> StateSet;
-    typedef map<StateSet, dstate_id_t> StateMap;
+struct Big_Traits {
+    using StateSet = dynamic_bitset<>;
+    using StateMap = map<StateSet, dstate_id_t>;
 
+    static StateSet init_states(u32 num) {
+        return StateSet(num);
+    }
+
+    static StateSet copy_states(const dynamic_bitset<> &in, UNUSED u32 num) {
+        assert(in.size() == num);
+        return in;
+    }
+};
+
+class Automaton_Big : public Automaton_Base<Big_Traits> {
+public:
     Automaton_Big(const NGHolder &graph_in,
-                  const ue2::unordered_map<NFAVertex, u32> &state_ids_in,
-                  som_type som, const vector<vector<CharReach>> &triggers,
-                  bool unordered_som)
-        : Automaton_Base(graph_in, state_ids_in), numStates(num_vertices(graph)),
-          init(numStates), initDS(numStates), squash(numStates),
-          accept(numStates), acceptEod(numStates), toppable(numStates),
-          dead(numStates) {
-        populateInit(graph, state_ids, &init, &initDS, &v_by_index);
-        populateAccepts(graph, &accept, &acceptEod);
-
-        start_anchored = DEAD_STATE + 1;
-        if (initDS == init) {
-            start_floating = start_anchored;
-        } else if (initDS.any()) {
-            start_floating = start_anchored + 1;
-        } else {
-            start_floating = DEAD_STATE;
-        }
-
-        if (!unordered_som) {
-            for (const auto &sq : findSquashers(graph, som)) {
-                NFAVertex v = sq.first;
-                u32 vert_id = graph[v].index;
-                squash.set(vert_id);
-                squash_mask[vert_id] = shrinkStateSet(sq.second);
-            }
-        }
-
-        cr_by_index = populateCR(graph, v_by_index, alpha);
-        if (is_triggered(graph)) {
-            markToppableStarts(graph, state_ids, false, triggers, &toppable);
-        }
-    }
-
-private:
-    // Convert an NFAStateSet (as used by the squash code) into a StateSet.
-    StateSet shrinkStateSet(const NFAStateSet &in) const {
-        StateSet out(dead.size());
-        for (size_t i = in.find_first(); i != in.npos && i < out.size();
-             i = in.find_next(i)) {
-            out.set(i);
-        }
-        return out;
-    }
-
-public:
-    void transition(const StateSet &in, StateSet *next) {
-        transition_graph(*this, v_by_index, in, next);
-    }
-
-    const vector<StateSet> initial() {
-        vector<StateSet> rv(1, init);
-        if (start_floating != DEAD_STATE && start_floating != start_anchored) {
-            rv.push_back(initDS);
-        }
-        return rv;
-    }
-
-private:
-    void reports_i(const StateSet &in, bool eod, flat_set<ReportID> &rv) {
-        StateSet acc = in & (eod ? acceptEod : accept);
-        for (size_t i = acc.find_first(); i != StateSet::npos;
-             i = acc.find_next(i)) {
-            NFAVertex v = v_by_index[i];
-            DEBUG_PRINTF("marking report\n");
-            const auto &my_reports = graph[v].reports;
-            rv.insert(my_reports.begin(), my_reports.end());
-        }
-    }
-
-public:
-    void reports(const StateSet &in, flat_set<ReportID> &rv) {
-        reports_i(in, false, rv);
-    }
-    void reportsEod(const StateSet &in, flat_set<ReportID> &rv) {
-        reports_i(in, true, rv);
-    }
-
-public:
-    u32 numStates;
-    vector<NFAVertex> v_by_index;
-    vector<CharReach> cr_by_index; /* pre alpha'ed */
-    StateSet init;
-    StateSet initDS;
-    StateSet squash; /* states which allow us to mask out other states */
-    StateSet accept;
-    StateSet acceptEod;
-    StateSet toppable; /* states which are allowed to be on when a top arrives,
-                        * triggered dfas only */
-    map<u32, StateSet> squash_mask;
-    StateSet dead;
+                  const flat_set<NFAVertex> &unused_in, som_type som,
+                  const vector<vector<CharReach>> &triggers, bool unordered_som)
+        : Automaton_Base(graph_in, unused_in, som, triggers, unordered_som) {}
 };
 
-class Automaton_Graph : public Automaton_Base {
-public:
-    typedef bitfield<NFA_STATE_LIMIT> StateSet;
-    typedef ue2::unordered_map<StateSet, dstate_id_t> StateMap;
+struct Graph_Traits {
+    using StateSet = bitfield<NFA_STATE_LIMIT>;
+    using StateMap = ue2::unordered_map<StateSet, dstate_id_t>;
 
-    Automaton_Graph(const NGHolder &graph_in,
-                    const ue2::unordered_map<NFAVertex, u32> &state_ids_in,
-                    som_type som, const vector<vector<CharReach>> &triggers,
-                    bool unordered_som)
-        : Automaton_Base(graph_in, state_ids_in) {
-        populateInit(graph, state_ids, &init, &initDS, &v_by_index);
-        populateAccepts(graph, &accept, &acceptEod);
-
-        start_anchored = DEAD_STATE + 1;
-        if (initDS == init) {
-            start_floating = start_anchored;
-        } else if (initDS.any()) {
-            start_floating = start_anchored + 1;
-        } else {
-            start_floating = DEAD_STATE;
-        }
-
-        if (!unordered_som) {
-            for (const auto &sq : findSquashers(graph, som)) {
-                NFAVertex v = sq.first;
-                u32 vert_id = graph[v].index;
-                squash.set(vert_id);
-                squash_mask[vert_id] = shrinkStateSet(sq.second);
-            }
-        }
-
-        cr_by_index = populateCR(graph, v_by_index, alpha);
-        if (is_triggered(graph)) {
-            dynamic_bitset<> temp(NFA_STATE_LIMIT);
-            markToppableStarts(graph, state_ids, false, triggers, &temp);
-            toppable = bitfield<NFA_STATE_LIMIT>(temp);
-        }
+    static StateSet init_states(UNUSED u32 num) {
+        assert(num <= NFA_STATE_LIMIT);
+        return StateSet();
     }
 
-private:
-    // Convert an NFAStateSet (as used by the squash code) into a StateSet.
-    StateSet shrinkStateSet(const NFAStateSet &in) const {
-        StateSet out;
+    static StateSet copy_states(const dynamic_bitset<> &in, u32 num) {
+        StateSet out = init_states(num);
         for (size_t i = in.find_first(); i != in.npos && i < out.size();
              i = in.find_next(i)) {
             out.set(i);
         }
         return out;
     }
+};
 
+class Automaton_Graph : public Automaton_Base<Graph_Traits> {
 public:
-    void transition(const StateSet &in, StateSet *next) {
-        transition_graph(*this, v_by_index, in, next);
-    }
-
-    const vector<StateSet> initial() {
-        vector<StateSet> rv(1, init);
-        if (start_floating != DEAD_STATE && start_floating != start_anchored) {
-            rv.push_back(initDS);
-        }
-        return rv;
-    }
-
-private:
-    void reports_i(const StateSet &in, bool eod, flat_set<ReportID> &rv) {
-        StateSet acc = in & (eod ? acceptEod : accept);
-        for (size_t i = acc.find_first(); i != StateSet::npos;
-             i = acc.find_next(i)) {
-            NFAVertex v = v_by_index[i];
-            DEBUG_PRINTF("marking report\n");
-            const auto &my_reports = graph[v].reports;
-            rv.insert(my_reports.begin(), my_reports.end());
-        }
-    }
-
-public:
-    void reports(const StateSet &in, flat_set<ReportID> &rv) {
-        reports_i(in, false, rv);
-    }
-    void reportsEod(const StateSet &in, flat_set<ReportID> &rv) {
-        reports_i(in, true, rv);
-    }
-
-public:
-    vector<NFAVertex> v_by_index;
-    vector<CharReach> cr_by_index; /* pre alpha'ed */
-    StateSet init;
-    StateSet initDS;
-    StateSet squash; /* states which allow us to mask out other states */
-    StateSet accept;
-    StateSet acceptEod;
-    StateSet toppable; /* states which are allowed to be on when a top arrives,
-                        * triggered dfas only */
-    map<u32, StateSet> squash_mask;
-    StateSet dead;
+    Automaton_Graph(const NGHolder &graph_in,
+                    const flat_set<NFAVertex> &unused_in, som_type som,
+                    const vector<vector<CharReach>> &triggers,
+                    bool unordered_som)
+        : Automaton_Base(graph_in, unused_in, som, triggers, unordered_som) {}
 };
 
 class Automaton_Haig_Merge {
@@ -481,11 +431,10 @@ bool is_any_start_inc_virtual(NFAVertex v, const NGHolder &g) {
 }
 
 static
-s32 getSlotID(const NGHolder &g,
-              UNUSED const ue2::unordered_map<NFAVertex, u32> &state_ids,
+s32 getSlotID(const NGHolder &g, UNUSED const flat_set<NFAVertex> &unused,
               NFAVertex v) {
     if (is_triggered(g) && v == g.start) {
-        assert(state_ids.at(v) != NO_STATE);
+        assert(!contains(unused, v));
     } else if (is_any_start_inc_virtual(v, g)) {
         return CREATE_NEW_SOM;
     }
@@ -516,8 +465,7 @@ void haig_do_preds(const NGHolder &g, const stateset &nfa_states,
 
 template<typename stateset>
 static
-void haig_do_report(const NGHolder &g,
-                    const ue2::unordered_map<NFAVertex, u32> &state_ids,
+void haig_do_report(const NGHolder &g, const flat_set<NFAVertex> &unused,
                     NFAVertex accept_v, const stateset &source_nfa_states,
                     const vector<NFAVertex> &state_mapping,
                     set<som_report> &out) {
@@ -528,7 +476,7 @@ void haig_do_report(const NGHolder &g,
             continue;
         }
         for (ReportID report_id : g[v].reports) {
-            out.insert(som_report(report_id, getSlotID(g, state_ids, v)));
+            out.insert(som_report(report_id, getSlotID(g, unused, v)));
         }
     }
 }
@@ -565,14 +513,14 @@ void haig_note_starts(const NGHolder &g, map<u32, u32> *out) {
 template<class Auto>
 static
 bool doHaig(const NGHolder &g,
-            const ue2::unordered_map<NFAVertex, u32> &state_ids,
+            const flat_set<NFAVertex> &unused,
             som_type som, const vector<vector<CharReach>> &triggers,
             bool unordered_som, raw_som_dfa *rdfa) {
     u32 state_limit = HAIG_FINAL_DFA_STATE_LIMIT; /* haig never backs down from
                                                      a fight */
     typedef typename Auto::StateSet StateSet;
     vector<StateSet> nfa_state_map;
-    Auto n(g, state_ids, som, triggers, unordered_som);
+    Auto n(g, unused, som, triggers, unordered_som);
     try {
         if (determinise(n, rdfa->states, state_limit, &nfa_state_map)) {
             DEBUG_PRINTF("state limit exceeded\n");
@@ -602,9 +550,9 @@ bool doHaig(const NGHolder &g,
         haig_do_preds(g, source_states, n.v_by_index,
                       rdfa->state_som.back().preds);
 
-        haig_do_report(g, state_ids, g.accept, source_states, n.v_by_index,
+        haig_do_report(g, unused, g.accept, source_states, n.v_by_index,
                        rdfa->state_som.back().reports);
-        haig_do_report(g, state_ids, g.acceptEod, source_states, n.v_by_index,
+        haig_do_report(g, unused, g.acceptEod, source_states, n.v_by_index,
                        rdfa->state_som.back().reports_eod);
     }
 
@@ -613,10 +561,10 @@ bool doHaig(const NGHolder &g,
     return true;
 }
 
-unique_ptr<raw_som_dfa> attemptToBuildHaig(NGHolder &g, som_type som,
-                                   u32 somPrecision,
-                                   const vector<vector<CharReach> > &triggers,
-                                   const Grey &grey, bool unordered_som) {
+unique_ptr<raw_som_dfa>
+attemptToBuildHaig(const NGHolder &g, som_type som, u32 somPrecision,
+                   const vector<vector<CharReach>> &triggers, const Grey &grey,
+                   bool unordered_som) {
     assert(is_triggered(g) != triggers.empty());
     assert(!unordered_som || is_triggered(g));
 
@@ -625,13 +573,12 @@ unique_ptr<raw_som_dfa> attemptToBuildHaig(NGHolder &g, som_type som,
         return nullptr;
     }
 
-    auto state_ids = numberStates(g);
-    dropUnusedStarts(g, state_ids);
-
     DEBUG_PRINTF("attempting to build haig \n");
     assert(allMatchStatesHaveReports(g));
     assert(hasCorrectlyNumberedVertices(g));
 
+    auto unused = findUnusedStates(g);
+
     u32 numStates = num_vertices(g);
     if (numStates > HAIG_MAX_NFA_STATE) {
         DEBUG_PRINTF("giving up... looks too big\n");
@@ -645,11 +592,11 @@ unique_ptr<raw_som_dfa> attemptToBuildHaig(NGHolder &g, som_type som,
     bool rv;
     if (numStates <= NFA_STATE_LIMIT) {
         /* fast path */
-        rv = doHaig<Automaton_Graph>(g, state_ids, som, triggers, unordered_som,
+        rv = doHaig<Automaton_Graph>(g, unused, som, triggers, unordered_som,
                                      rdfa.get());
     } else {
         /* not the fast path */
-        rv = doHaig<Automaton_Big>(g, state_ids, som, triggers, unordered_som,
+        rv = doHaig<Automaton_Big>(g, unused, som, triggers, unordered_som,
                                    rdfa.get());
     }
 
diff --git a/src/nfagraph/ng_haig.h b/src/nfagraph/ng_haig.h
index 1df5e2f0..baff2f58 100644
--- a/src/nfagraph/ng_haig.h
+++ b/src/nfagraph/ng_haig.h
@@ -54,10 +54,10 @@ struct raw_som_dfa;
  * between)
  */
 
-std::unique_ptr<raw_som_dfa> attemptToBuildHaig(NGHolder &g, som_type som,
-                         u32 somPrecision,
-                         const std::vector<std::vector<CharReach> > &triggers,
-                         const Grey &grey, bool unordered_som_triggers = false);
+std::unique_ptr<raw_som_dfa>
+attemptToBuildHaig(const NGHolder &g, som_type som, u32 somPrecision,
+                   const std::vector<std::vector<CharReach>> &triggers,
+                   const Grey &grey, bool unordered_som_triggers = false);
 
 std::unique_ptr<raw_som_dfa>
 attemptToMergeHaig(const std::vector<const raw_som_dfa *> &dfas,
diff --git a/src/nfagraph/ng_lbr.cpp b/src/nfagraph/ng_lbr.cpp
index b9cacaa7..d7183817 100644
--- a/src/nfagraph/ng_lbr.cpp
+++ b/src/nfagraph/ng_lbr.cpp
@@ -36,17 +36,19 @@
 #include "ng_holder.h"
 #include "ng_repeat.h"
 #include "ng_reports.h"
-#include "nfa/shufticompile.h"
-#include "nfa/trufflecompile.h"
+#include "nfa/castlecompile.h"
 #include "nfa/lbr_internal.h"
 #include "nfa/nfa_internal.h"
 #include "nfa/repeatcompile.h"
+#include "nfa/shufticompile.h"
+#include "nfa/trufflecompile.h"
 #include "util/alloc.h"
 #include "util/bitutils.h" // for lg2
 #include "util/compile_context.h"
 #include "util/container.h"
 #include "util/depth.h"
 #include "util/dump_charclass.h"
+#include "util/report_manager.h"
 #include "util/verify_types.h"
 
 using namespace std;
@@ -294,13 +296,19 @@ aligned_unique_ptr<NFA> constructLBR(const CharReach &cr,
     return nfa;
 }
 
-aligned_unique_ptr<NFA> constructLBR(const PureRepeat &repeat,
+aligned_unique_ptr<NFA> constructLBR(const CastleProto &proto,
                                      const vector<vector<CharReach>> &triggers,
-                                     const CompileContext &cc) {
+                                     const CompileContext &cc,
+                                     const ReportManager &rm) {
     if (!cc.grey.allowLbr) {
         return nullptr;
     }
 
+    if (proto.repeats.size() != 1) {
+        return nullptr;
+    }
+
+    const PureRepeat &repeat = proto.repeats.begin()->second;
     assert(!repeat.reach.none());
 
     if (repeat.reports.size() != 1) {
@@ -317,6 +325,9 @@ aligned_unique_ptr<NFA> constructLBR(const PureRepeat &repeat,
     }
 
     ReportID report = *repeat.reports.begin();
+    if (has_managed_reports(proto.kind)) {
+        report = rm.getProgramOffset(report);
+    }
 
     DEBUG_PRINTF("building LBR %s\n", repeat.bounds.str().c_str());
     return constructLBR(repeat.reach, repeat.bounds.min, repeat.bounds.max,
@@ -326,7 +337,8 @@ aligned_unique_ptr<NFA> constructLBR(const PureRepeat &repeat,
 /** \brief Construct an LBR engine from the given graph \p g. */
 aligned_unique_ptr<NFA> constructLBR(const NGHolder &g,
                                      const vector<vector<CharReach>> &triggers,
-                                     const CompileContext &cc) {
+                                     const CompileContext &cc,
+                                     const ReportManager &rm) {
     if (!cc.grey.allowLbr) {
         return nullptr;
     }
@@ -335,8 +347,13 @@ aligned_unique_ptr<NFA> constructLBR(const NGHolder &g,
     if (!isPureRepeat(g, repeat)) {
         return nullptr;
     }
+    if (repeat.reports.size() != 1) {
+        DEBUG_PRINTF("too many reports\n");
+        return nullptr;
+    }
 
-    return constructLBR(repeat, triggers, cc);
+    CastleProto proto(g.kind, repeat);
+    return constructLBR(proto, triggers, cc, rm);
 }
 
 /** \brief True if graph \p g could be turned into an LBR engine. */
diff --git a/src/nfagraph/ng_lbr.h b/src/nfagraph/ng_lbr.h
index fad079ae..99cb0fcb 100644
--- a/src/nfagraph/ng_lbr.h
+++ b/src/nfagraph/ng_lbr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -46,22 +46,22 @@ namespace ue2 {
 class CharReach;
 class NGHolder;
 class ReportManager;
+struct CastleProto;
 struct CompileContext;
-struct DepthMinMax;
 struct Grey;
-struct PureRepeat;
 
 /** \brief Construct an LBR engine from the given graph \p g. */
 aligned_unique_ptr<NFA>
 constructLBR(const NGHolder &g,
              const std::vector<std::vector<CharReach>> &triggers,
-             const CompileContext &cc);
+             const CompileContext &cc, const ReportManager &rm);
 
-/** \brief Construct an LBR engine from the given PureRepeat. */
+/** \brief Construct an LBR engine from the given CastleProto, which should
+ * contain only one repeat. */
 aligned_unique_ptr<NFA>
-constructLBR(const PureRepeat &repeat,
+constructLBR(const CastleProto &proto,
              const std::vector<std::vector<CharReach>> &triggers,
-             const CompileContext &cc);
+             const CompileContext &cc, const ReportManager &rm);
 
 /** \brief True if graph \p g could be turned into an LBR engine. */
 bool isLBR(const NGHolder &g, const Grey &grey);
diff --git a/src/nfagraph/ng_limex.cpp b/src/nfagraph/ng_limex.cpp
index 17f93bb2..713fe370 100644
--- a/src/nfagraph/ng_limex.cpp
+++ b/src/nfagraph/ng_limex.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -50,8 +50,9 @@
 #include "util/compile_context.h"
 #include "util/container.h"
 #include "util/graph_range.h"
-#include "util/verify_types.h"
+#include "util/report_manager.h"
 #include "util/ue2_containers.h"
+#include "util/verify_types.h"
 
 #include <map>
 #include <vector>
@@ -346,6 +347,25 @@ prepareGraph(const NGHolder &h_in, const ReportManager *rm,
     return h;
 }
 
+static
+void remapReportsToPrograms(NGHolder &h, const ReportManager &rm) {
+    for (const auto &v : vertices_range(h)) {
+        auto &reports = h[v].reports;
+        if (reports.empty()) {
+            continue;
+        }
+        auto old_reports = reports;
+        reports.clear();
+        for (const ReportID &id : old_reports) {
+            u32 program = rm.getProgramOffset(id);
+            reports.insert(program);
+        }
+        DEBUG_PRINTF("vertex %u: remapped reports {%s} to programs {%s}\n",
+                     h[v].index, as_string_list(old_reports).c_str(),
+                     as_string_list(reports).c_str());
+    }
+}
+
 static
 aligned_unique_ptr<NFA>
 constructNFA(const NGHolder &h_in, const ReportManager *rm,
@@ -393,6 +413,11 @@ constructNFA(const NGHolder &h_in, const ReportManager *rm,
 
     set<NFAVertex> zombies = findZombies(*h, br_cyclic, state_ids, cc);
 
+    if (generates_callbacks(*h)) {
+        assert(rm);
+        remapReportsToPrograms(*h, *rm);
+    }
+
     if (!cc.streaming || !cc.grey.compressNFAState) {
         compress_state = false;
     }
diff --git a/src/nfagraph/ng_limex_accel.cpp b/src/nfagraph/ng_limex_accel.cpp
index da103f8d..1f991f19 100644
--- a/src/nfagraph/ng_limex_accel.cpp
+++ b/src/nfagraph/ng_limex_accel.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -37,12 +37,15 @@
 #include "ue2common.h"
 
 #include "nfa/accel.h"
+#include "nfa/multiaccel_compilehelper.h"
 
 #include "util/bitutils.h" // for CASE_CLEAR
 #include "util/charreach.h"
+#include "util/compile_context.h"
 #include "util/container.h"
 #include "util/dump_charclass.h"
 #include "util/graph_range.h"
+#include "util/target_info.h"
 
 #include <algorithm>
 #include <map>
@@ -129,199 +132,6 @@ void findAccelFriends(const NGHolder &g, NFAVertex v,
     }
 }
 
-static
-void buildTwoByteStops(flat_set<pair<u8, u8>> &twobyte, const CharReach &cr1,
-                       const CharReach &cr2) {
-    for (size_t c1 = cr1.find_first(); c1 != cr1.npos; c1 = cr1.find_next(c1)) {
-        for (size_t c2 = cr2.find_first(); c2 != cr2.npos;
-             c2 = cr2.find_next(c2)) {
-            twobyte.emplace((u8)c1, (u8)c2);
-        }
-    }
-}
-
-static
-void findStopLiteralsAtVertex(NFAVertex v, const NGHolder &g,
-                              DoubleAccelInfo &build) {
-    DEBUG_PRINTF("state %u\n", g[v].index);
-
-    // double-byte accel is possible: calculate all single- and double-byte
-    // accel literals.
-    const CharReach &cr1 = g[v].char_reach;
-
-    if (edge(v, g.accept, g).second) {
-        // If this first byte is an accept state, it must contribute a
-        // single-byte escape. We can still go on and calculate additional
-        // double-byte ones, though.
-        /* TODO: fix for rose */
-        build.stop1 |= cr1;
-    }
-
-    flat_set<pair<u8, u8>> twobyte; // for just this starting state
-    bool single = false;
-
-    for (auto w : adjacent_vertices_range(v, g)) {
-        if (w == g.accept || w == g.acceptEod) {
-            continue;
-        }
-        const CharReach &cr2 = g[w].char_reach;
-        size_t count = cr1.count() * cr2.count() + build.stop2.size();
-        if (count > 0 && count <= 8) { // can't do more than 8 two-byte
-            buildTwoByteStops(twobyte, cr1, cr2);
-        } else {
-            // two many two-byte literals, add the first byte as single
-            single = true;
-            break;
-        }
-    }
-
-    if (single || twobyte.empty()) {
-        assert(!cr1.none());
-        build.stop1 |= cr1;
-    } else {
-        assert(!twobyte.empty());
-        build.stop2.insert(twobyte.begin(), twobyte.end());
-    }
-}
-
-static
-bool is_bit5_insensitive(const flat_set<pair<u8, u8>> &stop) {
-    if (stop.size() != 4) {
-        return false;
-    }
-
-    const u8 a = stop.begin()->first & CASE_CLEAR;
-    const u8 b = stop.begin()->second & CASE_CLEAR;
-
-    for (flat_set<pair<u8, u8>>::const_iterator it = stop.begin();
-         it != stop.end(); ++it) {
-        if ((it->first & CASE_CLEAR) != a || (it->second & CASE_CLEAR) != b) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static
-bool is_dverm(const DoubleAccelInfo &a) {
-    if (a.stop1.any()) {
-        return false;
-    }
-
-    if (a.stop2.size() == 1) {
-        return true;
-    }
-
-    return is_bit5_insensitive(a.stop2);
-}
-
-static
-bool is_double_better(const DoubleAccelInfo &a, const DoubleAccelInfo &b) {
-    /* Note: this is not an operator< */
-
-    if (a.stop2.empty()) {
-        return false;
-    }
-
-    if (b.stop2.empty()) {
-        return true;
-    }
-
-    if (a.stop1.count() > b.stop1.count()) {
-        return false;
-    }
-
-    if (a.stop1.count() < b.stop1.count()) {
-        return true;
-    }
-
-    bool a_dvm = is_dverm(a);
-    bool b_dvm = is_dverm(b);
-
-    if (b_dvm && !a_dvm) {
-        return false;
-    }
-
-    if (!b_dvm && a_dvm) {
-        return true;
-    }
-
-    if (a.stop2.size() > b.stop2.size()) {
-        return false;
-    }
-
-    if (a.stop2.size() < b.stop2.size()) {
-        return true;
-    }
-
-    return a.offset < b.offset;
-}
-
-/** \brief Find the escape literals for a two byte accel at the given accel
- * offset */
-static
-void findDoubleAccel(const NGHolder &g, NFAVertex v, u32 accel_offset,
-                     DoubleAccelInfo &build) {
-    DEBUG_PRINTF("find double accel +%u for vertex %u\n", accel_offset,
-                  g[v].index);
-    build.offset = accel_offset;
-
-    // Our accel state contributes single-byte escapes
-    build.stop1 |= ~g[v].char_reach;
-
-    flat_set<NFAVertex> searchStates; // states that contribute stop literals
-    searchStates.insert(v); /* TODO: verify */
-
-    /* Note: We cannot search past an accepting state */
-    /* TODO: remove restriction for non-callback generating */
-    flat_set<NFAVertex> nextStates;
-
-    insert(&nextStates, adjacent_vertices(v, g));
-    nextStates.erase(v);
-    nextStates.erase(g.accept);
-    nextStates.erase(g.acceptEod);
-
-    searchStates.swap(nextStates);
-    nextStates.clear();
-
-    // subsequent iterations are simpler, just follow all edges
-    for (u32 j = 1; j <= accel_offset; j++) {
-        for (auto u : searchStates) {
-            insert(&nextStates, adjacent_vertices(u, g));
-            if (edge(u, g.accept, g).second) {
-                nextStates.clear();
-                break;
-            }
-            nextStates.erase(g.accept);
-            nextStates.erase(g.acceptEod);
-        }
-
-        searchStates.swap(nextStates);
-        nextStates.clear();
-    }
-
-    vector<NFAVertex> sorted;
-    insert(&sorted, sorted.end(), searchStates);
-    sort(sorted.begin(), sorted.end(), make_index_ordering(g));
-    for (auto sv : sorted) {
-        findStopLiteralsAtVertex(sv, g, build);
-    }
-}
-
-DoubleAccelInfo findBestDoubleAccelInfo(const NGHolder &g, NFAVertex v) {
-    DoubleAccelInfo rv;
-    for (u32 offset = 0; offset <= MAX_ACCEL_DEPTH; offset++) {
-        DoubleAccelInfo b_temp;
-        findDoubleAccel(g, v, offset, b_temp);
-        if (is_double_better(b_temp, rv)) {
-            rv = b_temp;
-        }
-    }
-
-    return rv;
-}
-
 static
 void findPaths(const NGHolder &g, NFAVertex v,
                const vector<CharReach> &refined_cr,
@@ -380,70 +190,242 @@ void findPaths(const NGHolder &g, NFAVertex v,
     }
 }
 
-static
-AccelScheme merge(const AccelScheme &a, const AccelScheme &b) {
-    return AccelScheme(a.cr | b.cr, MAX(a.offset, b.offset));
-}
+struct SAccelScheme {
+    SAccelScheme(const CharReach &cr_in, u32 offset_in)
+        : cr(cr_in), offset(offset_in) {
+        assert(offset <= MAX_ACCEL_DEPTH);
+    }
+
+    SAccelScheme() {}
+
+    bool operator<(const SAccelScheme &b) const {
+        const SAccelScheme &a = *this;
+
+        const size_t a_count = cr.count(), b_count = b.cr.count();
+        if (a_count != b_count) {
+            return a_count < b_count;
+        }
+
+        /* TODO: give bonus if one is a 'caseless' character */
+        ORDER_CHECK(offset);
+        ORDER_CHECK(cr);
+        return false;
+    }
+
+    CharReach cr = CharReach::dot();
+    u32 offset = MAX_ACCEL_DEPTH + 1;
+};
 
 static
 void findBest(vector<vector<CharReach> >::const_iterator pb,
               vector<vector<CharReach> >::const_iterator pe,
-              const AccelScheme &curr, AccelScheme *best) {
+              const SAccelScheme &curr, SAccelScheme *best) {
     assert(curr.offset <= MAX_ACCEL_DEPTH);
     DEBUG_PRINTF("paths left %zu\n", pe - pb);
     if (pb == pe) {
+        if (curr < *best) {
+            DEBUG_PRINTF("new best\n");
+            *best = curr;
+        }
         *best = curr;
         return;
     }
 
     DEBUG_PRINTF("p len %zu\n", pb->end() - pb->begin());
 
-    vector<AccelScheme> priority_path;
+    vector<SAccelScheme> priority_path;
+    priority_path.reserve(pb->size());
     u32 i = 0;
     for (vector<CharReach>::const_iterator p = pb->begin(); p != pb->end();
          ++p, i++) {
-        priority_path.push_back(AccelScheme(*p & ~curr.cr, i));
+        SAccelScheme as(*p | curr.cr, MAX(i, curr.offset));
+        if (*best < as) {
+            DEBUG_PRINTF("worse\n");
+            continue;
+        }
+        priority_path.push_back(move(as));
     }
 
     sort(priority_path.begin(), priority_path.end());
-    for (vector<AccelScheme>::iterator it = priority_path.begin();
-         it != priority_path.end(); ++it) {
-        vector<AccelScheme>::iterator jt = it + 1;
+    for (auto it = priority_path.begin(); it != priority_path.end(); ++it) {
+        auto jt = next(it);
         for (; jt != priority_path.end(); ++jt) {
             if (!it->cr.isSubsetOf(jt->cr)) {
                 break;
             }
         }
-        priority_path.erase(it + 1, jt);
+        priority_path.erase(next(it), jt);
         DEBUG_PRINTF("||%zu\n", it->cr.count());
     }
     DEBUG_PRINTF("---\n");
 
-    for (vector<AccelScheme>::const_iterator it = priority_path.begin();
+    for (vector<SAccelScheme>::const_iterator it = priority_path.begin();
          it != priority_path.end(); ++it) {
         DEBUG_PRINTF("%u:|| = %zu; p remaining len %zu\n", i, it->cr.count(),
                      priority_path.end() - it);
 
-        AccelScheme in = merge(curr, *it);
+        SAccelScheme in = move(*it);
 
-        if (in > *best) {
+        if (*best < in) {
             DEBUG_PRINTF("worse\n");
             continue;
         }
-        AccelScheme temp = *best;
-        findBest(pb + 1, pe, in, &temp);
-        if (temp < *best) {
-            DEBUG_PRINTF("new best\n");
-            *best = temp;
-            if (curr.cr == best->cr) {
-                return; /* could only get better by offset */
-            }
+        findBest(pb + 1, pe, in, best);
+
+        if (curr.cr == best->cr) {
+            return; /* could only get better by offset */
         }
     }
 }
 
-#ifdef DEBUG
+struct DAccelScheme {
+    DAccelScheme(const CharReach &cr_in, u32 offset_in)
+        : double_cr(cr_in), double_offset(offset_in) {
+        assert(double_offset <= MAX_ACCEL_DEPTH);
+    }
 
+    bool operator<(const DAccelScheme &b) const {
+        const DAccelScheme &a = *this;
+
+        size_t a_dcount = a.double_cr.count();
+        size_t b_dcount = b.double_cr.count();
+
+        assert(!a.double_byte.empty() || a_dcount || a.double_offset);
+        assert(!b.double_byte.empty() || b_dcount || b.double_offset);
+
+        if (a_dcount != b_dcount) {
+            return a_dcount < b_dcount;
+        }
+
+        if (!a_dcount) {
+            bool cd_a = buildDvermMask(a.double_byte);
+            bool cd_b = buildDvermMask(b.double_byte);
+            if (cd_a != cd_b) {
+                return cd_a > cd_b;
+            }
+        }
+
+        ORDER_CHECK(double_byte.size());
+        ORDER_CHECK(double_offset);
+
+        /* TODO: give bonus if one is a 'caseless' character */
+        ORDER_CHECK(double_byte);
+        ORDER_CHECK(double_cr);
+
+        return false;
+    }
+
+    ue2::flat_set<std::pair<u8, u8> > double_byte;
+    CharReach double_cr;
+    u32 double_offset = 0;
+};
+
+static
+DAccelScheme make_double_accel(DAccelScheme as, CharReach cr_1,
+                               const CharReach &cr_2_in, u32 offset_in) {
+    cr_1 &= ~as.double_cr;
+    CharReach cr_2 = cr_2_in & ~as.double_cr;
+    u32 offset = offset_in;
+
+    if (cr_1.none()) {
+        DEBUG_PRINTF("empty first element\n");
+        ENSURE_AT_LEAST(&as.double_offset, offset);
+        return as;
+    }
+
+    if (cr_2_in != cr_2 || cr_2.none()) {
+        offset = offset_in + 1;
+    }
+
+    size_t two_count = cr_1.count() * cr_2.count();
+
+    DEBUG_PRINTF("will generate raw %zu pairs\n", two_count);
+
+    if (!two_count) {
+        DEBUG_PRINTF("empty element\n");
+        ENSURE_AT_LEAST(&as.double_offset, offset);
+        return as;
+    }
+
+    if (two_count > DOUBLE_SHUFTI_LIMIT) {
+        if (cr_2.count() < cr_1.count()) {
+            as.double_cr |= cr_2;
+            offset = offset_in + 1;
+        } else {
+            as.double_cr |= cr_1;
+        }
+    } else {
+        for (auto i = cr_1.find_first(); i != CharReach::npos;
+             i = cr_1.find_next(i)) {
+            for (auto j = cr_2.find_first(); j != CharReach::npos;
+                 j = cr_2.find_next(j)) {
+                as.double_byte.emplace(i, j);
+            }
+        }
+    }
+
+    ENSURE_AT_LEAST(&as.double_offset, offset);
+    DEBUG_PRINTF("construct da %zu pairs, %zu singles, offset %u\n",
+                 as.double_byte.size(), as.double_cr.count(), as.double_offset);
+    return as;
+}
+
+static
+void findDoubleBest(vector<vector<CharReach> >::const_iterator pb,
+              vector<vector<CharReach> >::const_iterator pe,
+              const DAccelScheme &curr, DAccelScheme *best) {
+    assert(curr.double_offset <= MAX_ACCEL_DEPTH);
+    DEBUG_PRINTF("paths left %zu\n", pe - pb);
+    DEBUG_PRINTF("current base: %zu pairs, %zu singles, offset %u\n",
+                 curr.double_byte.size(), curr.double_cr.count(),
+                 curr.double_offset);
+    if (pb == pe) {
+        if (curr < *best) {
+            *best = curr;
+            DEBUG_PRINTF("new best: %zu pairs, %zu singles, offset %u\n",
+                         best->double_byte.size(), best->double_cr.count(),
+                         best->double_offset);
+        }
+        return;
+    }
+
+    DEBUG_PRINTF("p len %zu\n", pb->end() - pb->begin());
+
+    vector<DAccelScheme> priority_path;
+    priority_path.reserve(pb->size());
+    u32 i = 0;
+    for (vector<CharReach>::const_iterator p = pb->begin();
+         p != pb->end() && next(p) != pb->end();
+         ++p, i++) {
+        DAccelScheme as = make_double_accel(curr, *p, *next(p), i);
+        if (*best < as) {
+            DEBUG_PRINTF("worse\n");
+            continue;
+        }
+        priority_path.push_back(move(as));
+    }
+
+    sort(priority_path.begin(), priority_path.end());
+    DEBUG_PRINTF("%zu candidates for this path\n", priority_path.size());
+    DEBUG_PRINTF("input best: %zu pairs, %zu singles, offset %u\n",
+                 best->double_byte.size(), best->double_cr.count(),
+                 best->double_offset);
+
+    for (vector<DAccelScheme>::const_iterator it = priority_path.begin();
+         it != priority_path.end(); ++it) {
+        DAccelScheme in = move(*it);
+        DEBUG_PRINTF("in: %zu pairs, %zu singles, offset %u\n",
+                     in.double_byte.size(), in.double_cr.count(),
+                     in.double_offset);
+        if (*best < in) {
+            DEBUG_PRINTF("worse\n");
+            continue;
+        }
+        findDoubleBest(pb + 1, pe, in, best);
+    }
+}
+
+#ifdef DEBUG
 static
 void dumpPaths(const vector<vector<CharReach> > &paths) {
     for (vector<vector<CharReach> >::const_iterator p = paths.begin();
@@ -461,16 +443,13 @@ void dumpPaths(const vector<vector<CharReach> > &paths) {
 #endif
 
 static
-void blowoutPathsLessStrictSegment(vector<vector<CharReach> > *paths) {
+void blowoutPathsLessStrictSegment(vector<vector<CharReach> > &paths) {
     /* paths segments which are a superset of an earlier segment should never be
      * picked as an acceleration segment -> to improve processing just replace
      * with dot */
-    for (vector<vector<CharReach> >::iterator p = paths->begin();
-         p != paths->end(); ++p) {
-        for (vector<CharReach>::iterator it = p->begin(); it != p->end();
-             ++it) {
-            vector<CharReach>::iterator jt = it;
-            for (++jt; jt != p->end(); ++jt) {
+    for (auto &p : paths) {
+        for (auto it = p.begin(); it != p.end();  ++it) {
+            for (auto jt = next(it); jt != p.end(); ++jt) {
                 if (it->isSubsetOf(*jt)) {
                     *jt = CharReach::dot();
                 }
@@ -480,10 +459,10 @@ void blowoutPathsLessStrictSegment(vector<vector<CharReach> > *paths) {
 }
 
 static
-void unifyPathsLastSegment(vector<vector<CharReach> > *paths) {
+void unifyPathsLastSegment(vector<vector<CharReach> > &paths) {
     /* try to unify paths which only differ in the last segment */
-    for (vector<vector<CharReach> >::iterator p = paths->begin();
-         p != paths->end() && p + 1 != paths->end();) {
+    for (vector<vector<CharReach> >::iterator p = paths.begin();
+         p != paths.end() && p + 1 != paths.end();) {
         vector<CharReach> &a = *p;
         vector<CharReach> &b = *(p + 1);
 
@@ -501,7 +480,7 @@ void unifyPathsLastSegment(vector<vector<CharReach> > *paths) {
         if (i == a.size() - 1) {
             /* we can unify these paths */
             a[i] |= b[i];
-            paths->erase(p + 1);
+            paths.erase(p + 1);
         } else {
             ++p;
         }
@@ -509,27 +488,120 @@ void unifyPathsLastSegment(vector<vector<CharReach> > *paths) {
 }
 
 static
-void improvePaths(vector<vector<CharReach> > *paths) {
+void improvePaths(vector<vector<CharReach> > &paths) {
 #ifdef DEBUG
     DEBUG_PRINTF("orig paths\n");
-    dumpPaths(*paths);
+    dumpPaths(paths);
 #endif
     blowoutPathsLessStrictSegment(paths);
 
-    sort(paths->begin(), paths->end());
+    sort(paths.begin(), paths.end());
 
     unifyPathsLastSegment(paths);
 
 #ifdef DEBUG
     DEBUG_PRINTF("opt paths\n");
-    dumpPaths(*paths);
+    dumpPaths(paths);
 #endif
 }
 
+#define MAX_DOUBLE_ACCEL_PATHS 10
+
+static
+DAccelScheme findBestDoubleAccelScheme(vector<vector<CharReach> > paths,
+                                       const CharReach &terminating) {
+    DEBUG_PRINTF("looking for double accel, %zu terminating symbols\n",
+                 terminating.count());
+    unifyPathsLastSegment(paths);
+
+#ifdef DEBUG
+    DEBUG_PRINTF("paths:\n");
+    dumpPaths(paths);
+#endif
+
+    /* if there are too many paths, shorten the paths to reduce the number of
+     * distinct paths we have to consider */
+    while (paths.size() > MAX_DOUBLE_ACCEL_PATHS) {
+        for (auto &p : paths) {
+            if (p.empty()) {
+                return DAccelScheme(terminating, 0U);
+            }
+            p.pop_back();
+        }
+        unifyPathsLastSegment(paths);
+    }
+
+    if (paths.empty()) {
+        return DAccelScheme(terminating, 0U);
+    }
+
+    DAccelScheme curr(terminating, 0U);
+    DAccelScheme best(CharReach::dot(), 0U);
+    findDoubleBest(paths.begin(), paths.end(), curr, &best);
+    DEBUG_PRINTF("da %zu pairs, %zu singles\n", best.double_byte.size(),
+                 best.double_cr.count());
+    return best;
+}
+
+#define MAX_EXPLORE_PATHS 40
+
+AccelScheme findBestAccelScheme(vector<vector<CharReach> > paths,
+                                const CharReach &terminating,
+                                bool look_for_double_byte) {
+    AccelScheme rv;
+    if (look_for_double_byte) {
+        DAccelScheme da = findBestDoubleAccelScheme(paths, terminating);
+        if (da.double_byte.size() <= DOUBLE_SHUFTI_LIMIT) {
+            rv.double_byte = move(da.double_byte);
+            rv.double_cr = move(da.double_cr);
+            rv.double_offset = da.double_offset;
+        }
+    }
+
+    improvePaths(paths);
+
+    DEBUG_PRINTF("we have %zu paths\n", paths.size());
+    if (paths.size() > MAX_EXPLORE_PATHS) {
+        return rv; /* too many paths to explore */
+    }
+
+    /* if we were smart we would do something netflowy on the paths to find the
+     * best cut. But we aren't, so we will just brute force it.
+     */
+    SAccelScheme curr(terminating, 0U);
+    SAccelScheme best;
+    findBest(paths.begin(), paths.end(), curr, &best);
+
+    /* find best is a bit lazy in terms of minimising the offset, see if we can
+     * make it better. need to find the min max offset that we need.*/
+    u32 offset = 0;
+    for (vector<vector<CharReach> >::iterator p = paths.begin();
+         p != paths.end(); ++p) {
+        u32 i = 0;
+        for (vector<CharReach>::iterator it = p->begin(); it != p->end();
+             ++it, i++) {
+            if (it->isSubsetOf(best.cr)) {
+                break;
+            }
+        }
+        offset = MAX(offset, i);
+    }
+    assert(offset <= best.offset);
+    best.offset = offset;
+
+    rv.offset = best.offset;
+    rv.cr = best.cr;
+    if (rv.cr.count() < rv.double_cr.count()) {
+        rv.double_byte.clear();
+    }
+
+    return rv;
+}
+
 AccelScheme nfaFindAccel(const NGHolder &g, const vector<NFAVertex> &verts,
                          const vector<CharReach> &refined_cr,
                          const map<NFAVertex, BoundedRepeatSummary> &br_cyclic,
-                         bool allow_wide) {
+                         bool allow_wide, bool look_for_double_byte) {
     CharReach terminating;
     for (auto v : verts) {
         if (!hasSelfLoop(v, g)) {
@@ -576,36 +648,8 @@ AccelScheme nfaFindAccel(const NGHolder &g, const vector<NFAVertex> &verts,
         reverse(it->begin(), it->end());
     }
 
-    improvePaths(&paths);
-    DEBUG_PRINTF("we have %zu paths\n", paths.size());
-    if (paths.size() > 40) {
-        return AccelScheme(); /* too many paths to explore */
-    }
-
-    /* if we were smart we would do something netflowy on the paths to find the
-     * best cut. But we aren't, so we will just brute force it.
-     */
-    AccelScheme curr(terminating, 0U);
-    AccelScheme best;
-    findBest(paths.begin(), paths.end(), curr, &best);
-
-    /* find best is a bit lazy in terms of minimising the offset, see if we can
-     * make it better. need to find the min max offset that we need.*/
-    u32 offset = 0;
-    for (vector<vector<CharReach> >::iterator p = paths.begin();
-         p != paths.end(); ++p) {
-        u32 i = 0;
-        for (vector<CharReach>::iterator it = p->begin(); it != p->end();
-             ++it, i++) {
-            if (it->isSubsetOf(best.cr)) {
-                break;
-            }
-        }
-        offset = MAX(offset, i);
-    }
-    assert(offset <= best.offset);
-    best.offset = offset;
-    return best;
+    return findBestAccelScheme(std::move(paths), terminating,
+                               look_for_double_byte);
 }
 
 NFAVertex get_sds_or_proxy(const NGHolder &g) {
@@ -647,6 +691,134 @@ NFAVertex get_sds_or_proxy(const NGHolder &g) {
     return g.startDs;
 }
 
+static
+NFAVertex find_next(const NFAVertex v, const NGHolder &g) {
+    NFAVertex res = NFAGraph::null_vertex();
+    for (NFAVertex u :  adjacent_vertices_range(v, g)) {
+        if (u != v) {
+            res = u;
+            break;
+        }
+    }
+    return res;
+}
+
+/** \brief Check if vertex \a v is a multi accelerable state (for a limex NFA). */
+MultibyteAccelInfo nfaCheckMultiAccel(const NGHolder &g,
+                                      const vector<NFAVertex> &states,
+                                      const CompileContext &cc) {
+    // For a set of states to be accelerable, we basically have to have only
+    // one state to accelerate.
+    if (states.size() != 1) {
+        DEBUG_PRINTF("can't accelerate multiple states\n");
+        return MultibyteAccelInfo();
+    }
+
+    // Get our base vertex
+    NFAVertex v = states[0];
+
+    // We need the base vertex to be a self-looping dotall leading to exactly
+    // one vertex.
+    if (!hasSelfLoop(v, g)) {
+        DEBUG_PRINTF("base vertex has self-loop\n");
+        return MultibyteAccelInfo();
+    }
+
+    if (!g[v].char_reach.all()) {
+        DEBUG_PRINTF("can't accelerate anything but dot\n");
+        return MultibyteAccelInfo();
+    }
+
+    if (proper_out_degree(v, g) != 1) {
+        DEBUG_PRINTF("can't accelerate states with multiple successors\n");
+        return MultibyteAccelInfo();
+    }
+
+    // find our start vertex
+    NFAVertex cur = find_next(v, g);
+    if (cur == NFAGraph::null_vertex()) {
+        DEBUG_PRINTF("invalid start vertex\n");
+        return MultibyteAccelInfo();
+    }
+
+    bool has_offset = false;
+    u32 offset = 0;
+    CharReach cr = g[cur].char_reach;
+
+    // if we start with a dot, we have an offset, so defer figuring out the
+    // real CharReach for this accel scheme
+    if (cr == CharReach::dot()) {
+        has_offset = true;
+        offset = 1;
+    }
+
+    // figure out our offset
+    while (has_offset) {
+        // vertices have to have no self loops
+        if (hasSelfLoop(cur, g)) {
+            DEBUG_PRINTF("can't have self-loops\n");
+            return MultibyteAccelInfo();
+        }
+
+        // we have to have exactly 1 successor to have this acceleration scheme
+        if (out_degree(cur, g) != 1) {
+            DEBUG_PRINTF("can't have multiple successors\n");
+            return MultibyteAccelInfo();
+        }
+
+        cur = *adjacent_vertices(cur, g).first;
+
+        // if we met a special vertex, bail out
+        if (is_special(cur, g)) {
+            DEBUG_PRINTF("can't have special vertices\n");
+            return MultibyteAccelInfo();
+        }
+
+        // now, get the real char reach
+        if (g[cur].char_reach != CharReach::dot()) {
+            cr = g[cur].char_reach;
+            has_offset = false;
+        } else {
+            offset++;
+        }
+    }
+
+    // now, fire up the compilation machinery
+    target_t ti = cc.target_info;
+    unsigned max_len = ti.has_avx2() ? MULTIACCEL_MAX_LEN_AVX2 : MULTIACCEL_MAX_LEN_SSE;
+    MultiaccelCompileHelper mac(cr, offset, max_len);
+
+    while (mac.canAdvance()) {
+        // vertices have to have no self loops
+        if (hasSelfLoop(cur, g)) {
+            break;
+        }
+
+        // we have to have exactly 1 successor to have this acceleration scheme
+        if (out_degree(cur, g) != 1) {
+            break;
+        }
+
+        cur = *adjacent_vertices(cur, g).first;
+
+        // if we met a special vertex, bail out
+        if (is_special(cur, g)) {
+            break;
+        }
+
+        mac.advance(g[cur].char_reach);
+    }
+    MultibyteAccelInfo mai = mac.getBestScheme();
+#ifdef DEBUG
+    DEBUG_PRINTF("Multibyte acceleration scheme: type: %u offset: %u lengths: %u,%u\n",
+                 mai.type, mai.offset, mai.len1, mai.len2);
+    for (size_t c = mai.cr.find_first(); c != CharReach::npos; c = mai.cr.find_next(c)) {
+        DEBUG_PRINTF("multibyte accel char: %zu\n", c);
+    }
+#endif
+    return mai;
+}
+
 /** \brief Check if vertex \a v is an accelerable state (for a limex NFA). */
 bool nfaCheckAccel(const NGHolder &g, NFAVertex v,
                    const vector<CharReach> &refined_cr,
@@ -735,7 +907,9 @@ depth_done:
     for (unsigned int i = 0; i < depth; i++) {
         if (depthReach[i].none()) {
             DEBUG_PRINTF("red tape acceleration engine depth %u\n", i);
-            *as = AccelScheme(CharReach(), i);
+            *as = AccelScheme();
+            as->offset = i;
+            as->cr = CharReach();
             return true;
         }
     }
@@ -750,7 +924,8 @@ depth_done:
                 || (cra.count() == 2 && crb.count() == 2
                     && cra.isBit5Insensitive() && crb.isBit5Insensitive())) {
                 DEBUG_PRINTF("two-byte vermicelli, depth %u\n", i);
-                *as = AccelScheme(CharReach::dot(), i);
+                *as = AccelScheme();
+                as->offset = i;
                 return true;
             }
         }
@@ -760,17 +935,19 @@ depth_done:
     // literals)
     if (depth > 1) {
         for (unsigned int i = 0; i < (depth - 1); i++) {
-            if (depthReach[i].count()*depthReach[i+1].count() <= 8) {
+            if (depthReach[i].count() * depthReach[i+1].count()
+                <= DOUBLE_SHUFTI_LIMIT) {
                 DEBUG_PRINTF("two-byte shufti, depth %u\n", i);
-                *as = AccelScheme(CharReach::dot(), i);
+                *as = AccelScheme();
+                as->offset = i;
                 return true;
             }
         }
     }
 
-    // Look for one byte accel schemes verm/shufti;
+    // Look for offset accel schemes verm/shufti;
     vector<NFAVertex> verts(1, v);
-    *as = nfaFindAccel(g, verts, refined_cr, br_cyclic, allow_wide);
+    *as = nfaFindAccel(g, verts, refined_cr, br_cyclic, allow_wide, true);
     DEBUG_PRINTF("as width %zu\n", as->cr.count());
     return as->cr.count() <= ACCEL_MAX_STOP_CHAR || allow_wide;
 }
diff --git a/src/nfagraph/ng_limex_accel.h b/src/nfagraph/ng_limex_accel.h
index 005eddd2..cb3d1210 100644
--- a/src/nfagraph/ng_limex_accel.h
+++ b/src/nfagraph/ng_limex_accel.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -36,6 +36,8 @@
 #include "ng_holder.h"
 #include "ng_misc_opt.h"
 #include "ue2common.h"
+#include "nfa/accelcompile.h"
+#include "util/accel_scheme.h"
 #include "util/charreach.h"
 #include "util/order_check.h"
 #include "util/ue2_containers.h"
@@ -46,69 +48,48 @@
 namespace ue2 {
 
 /* compile time accel defs */
-#define MAX_ACCEL_DEPTH 4
 #define MAX_MERGED_ACCEL_STOPS 200
 #define ACCEL_MAX_STOP_CHAR 24
 #define ACCEL_MAX_FLOATING_STOP_CHAR 192 /* accelerating sds is important */
+#define MULTIACCEL_MIN_LEN 3
+#define MULTIACCEL_MAX_LEN_SSE 15
+#define MULTIACCEL_MAX_LEN_AVX2 31
+
+// forward-declaration of CompileContext
+struct CompileContext;
 
 void findAccelFriends(const NGHolder &g, NFAVertex v,
                   const std::map<NFAVertex, BoundedRepeatSummary> &br_cyclic,
                       u32 offset,
                       ue2::flat_set<NFAVertex> *friends);
 
-struct DoubleAccelInfo {
-    DoubleAccelInfo() : offset(0) {}
-    u32 offset;                         //!< offset correction to apply
-    CharReach stop1;                    //!< single-byte accel stop literals
-    flat_set<std::pair<u8, u8>> stop2;  //!< double-byte accel stop literals
-};
-
-DoubleAccelInfo findBestDoubleAccelInfo(const NGHolder &g, NFAVertex v);
-
-struct AccelScheme {
-    AccelScheme(const CharReach &cr_in, u32 offset_in)
-        : cr(cr_in), offset(offset_in) {
-        assert(offset <= MAX_ACCEL_DEPTH);
-    }
-    AccelScheme() : cr(CharReach::dot()), offset(MAX_ACCEL_DEPTH + 1) {}
-
-    bool operator<(const AccelScheme &b) const {
-        const AccelScheme &a = *this;
-
-        // Don't use ORDER_CHECK as it will (stupidly) eval count() too many
-        // times.
-        const size_t a_count = cr.count(), b_count = b.cr.count();
-        if (a_count != b_count) {
-            return a_count < b_count;
-        }
-
-        /* TODO: give bonus if one is a 'caseless' character */
-        ORDER_CHECK(offset);
-        ORDER_CHECK(cr);
-        return false;
-    }
-
-    bool operator>(const AccelScheme &b) const {
-        return b < *this;
-    }
-
-    CharReach cr;
-    u32 offset;
-};
+#define DOUBLE_SHUFTI_LIMIT 20
 
 NFAVertex get_sds_or_proxy(const NGHolder &g);
 
 AccelScheme nfaFindAccel(const NGHolder &g, const std::vector<NFAVertex> &verts,
                     const std::vector<CharReach> &refined_cr,
                     const std::map<NFAVertex, BoundedRepeatSummary> &br_cyclic,
-                    bool allow_wide);
+                    bool allow_wide, bool look_for_double_byte = false);
 
-/** \brief Check if vertex \a v is an accelerable state (for a limex NFA). */
+AccelScheme findBestAccelScheme(std::vector<std::vector<CharReach> > paths,
+                                const CharReach &terminating,
+                                bool look_for_double_byte = false);
+
+/** \brief Check if vertex \a v is an accelerable state (for a limex NFA). If a
+ *  single byte accel scheme is found it is placed into *as
+ */
 bool nfaCheckAccel(const NGHolder &g, NFAVertex v,
                    const std::vector<CharReach> &refined_cr,
                    const std::map<NFAVertex, BoundedRepeatSummary> &br_cyclic,
                    AccelScheme *as, bool allow_wide);
 
+/** \brief Check if vertex \a v is a multi accelerable state (for a limex NFA).
+ */
+MultibyteAccelInfo nfaCheckMultiAccel(const NGHolder &g,
+                                      const std::vector<NFAVertex> &verts,
+                                      const CompileContext &cc);
+
 } // namespace ue2
 
 #endif
diff --git a/src/nfagraph/ng_mcclellan.cpp b/src/nfagraph/ng_mcclellan.cpp
index 245dbefe..b1c6ff96 100644
--- a/src/nfagraph/ng_mcclellan.cpp
+++ b/src/nfagraph/ng_mcclellan.cpp
@@ -152,12 +152,11 @@ void getFullTransitionFromState(const raw_dfa &n, dstate_id_t state,
 
 template<typename stateset>
 static
-void populateInit(const NGHolder &g,
-                  const ue2::unordered_map<NFAVertex, u32> &state_ids,
+void populateInit(const NGHolder &g, const flat_set<NFAVertex> &unused,
                   stateset *init, stateset *init_deep,
                   vector<NFAVertex> *v_by_index) {
     for (auto v : vertices_range(g)) {
-        if (state_ids.at(v) == NO_STATE) {
+        if (contains(unused, v)) {
             continue;
         }
 
@@ -188,21 +187,22 @@ void populateInit(const NGHolder &g,
 }
 
 template<typename StateSet>
-void populateAccepts(const NGHolder &g,
-                     const ue2::unordered_map<NFAVertex, u32> &state_ids,
+void populateAccepts(const NGHolder &g, const flat_set<NFAVertex> &unused,
                      StateSet *accept, StateSet *acceptEod) {
     for (auto v : inv_adjacent_vertices_range(g.accept, g)) {
-        if (state_ids.at(v) != NO_STATE) {
-            accept->set(g[v].index);
+        if (contains(unused, v)) {
+            continue;
         }
+        accept->set(g[v].index);
     }
     for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) {
         if (v == g.accept) {
             continue;
         }
-        if (state_ids.at(v) != NO_STATE) {
-            acceptEod->set(g[v].index);
+        if (contains(unused, v)) {
+            continue;
         }
+        acceptEod->set(g[v].index);
     }
 }
 
@@ -315,8 +315,7 @@ bool triggerAllowed(const NGHolder &g, const NFAVertex v,
     return true;
 }
 
-void markToppableStarts(const NGHolder &g,
-                        const ue2::unordered_map<NFAVertex, u32> &state_ids,
+void markToppableStarts(const NGHolder &g, const flat_set<NFAVertex> &unused,
                         bool single_trigger,
                         const vector<vector<CharReach>> &triggers,
                         dynamic_bitset<> *out) {
@@ -325,14 +324,13 @@ void markToppableStarts(const NGHolder &g,
     }
 
     for (auto v : vertices_range(g)) {
-        if (state_ids.at(v) == NO_STATE) {
+        if (contains(unused, v)) {
             continue;
         }
-        u32 vert_id = g[v].index;
         for (const auto &trigger : triggers) {
             if (triggerAllowed(g, v, triggers, trigger)) {
-                DEBUG_PRINTF("idx %u is valid location for top\n", vert_id);
-                out->set(vert_id);
+                DEBUG_PRINTF("idx %u is valid location for top\n", g[v].index);
+                out->set(g[v].index);
                 break;
             }
         }
@@ -343,21 +341,26 @@ void markToppableStarts(const NGHolder &g,
 
 namespace {
 
-class Automaton_Big {
+template<typename Automaton_Traits>
+class Automaton_Base {
 public:
-    typedef dynamic_bitset<> StateSet;
-    typedef map<StateSet, dstate_id_t> StateMap;
+    using StateSet = typename Automaton_Traits::StateSet;
+    using StateMap = typename Automaton_Traits::StateMap;
 
-    Automaton_Big(const ReportManager *rm_in, const NGHolder &graph_in,
-                  const ue2::unordered_map<NFAVertex, u32> &state_ids_in,
-                  bool single_trigger,
-                  const vector<vector<CharReach>> &triggers, bool prunable_in)
-        : rm(rm_in), graph(graph_in), state_ids(state_ids_in),
-          numStates(num_vertices(graph)), init(numStates), initDS(numStates),
-          squash(numStates), accept(numStates), acceptEod(numStates),
-          toppable(numStates), prunable(prunable_in), dead(numStates) {
-        populateInit(graph, state_ids, &init, &initDS, &v_by_index);
-        populateAccepts(graph, state_ids, &accept, &acceptEod);
+    Automaton_Base(const ReportManager *rm_in, const NGHolder &graph_in,
+                   const flat_set<NFAVertex> &unused_in, bool single_trigger,
+                   const vector<vector<CharReach>> &triggers, bool prunable_in)
+        : rm(rm_in), graph(graph_in), numStates(num_vertices(graph)),
+          unused(unused_in), init(Automaton_Traits::init_states(numStates)),
+          initDS(Automaton_Traits::init_states(numStates)),
+          squash(Automaton_Traits::init_states(numStates)),
+          accept(Automaton_Traits::init_states(numStates)),
+          acceptEod(Automaton_Traits::init_states(numStates)),
+          toppable(Automaton_Traits::init_states(numStates)),
+          dead(Automaton_Traits::init_states(numStates)),
+          prunable(prunable_in) {
+        populateInit(graph, unused, &init, &initDS, &v_by_index);
+        populateAccepts(graph, unused, &accept, &acceptEod);
 
         start_anchored = DEAD_STATE + 1;
         if (initDS == init) {
@@ -379,15 +382,17 @@ public:
 
         cr_by_index = populateCR(graph, v_by_index, alpha);
         if (is_triggered(graph)) {
-            markToppableStarts(graph, state_ids, single_trigger, triggers,
-                               &toppable);
+            dynamic_bitset<> temp(numStates);
+            markToppableStarts(graph, unused, single_trigger, triggers,
+                               &temp);
+            toppable = Automaton_Traits::copy_states(temp, numStates);
         }
     }
 
 private:
     // Convert an NFAStateSet (as used by the squash code) into a StateSet
     StateSet shrinkStateSet(const NFAStateSet &in) const {
-        StateSet out(dead.size());
+        StateSet out = Automaton_Traits::init_states(numStates);
         for (size_t i = in.find_first(); i != in.npos && i < out.size();
              i = in.find_next(i)) {
             out.set(i);
@@ -401,7 +406,7 @@ public:
     }
 
     const vector<StateSet> initial() {
-        vector<StateSet> rv(1, init);
+        vector<StateSet> rv = {init};
         if (start_floating != DEAD_STATE && start_floating != start_anchored) {
             rv.push_back(initDS);
         }
@@ -438,8 +443,8 @@ private:
     const ReportManager *rm;
 public:
     const NGHolder &graph;
-    const ue2::unordered_map<NFAVertex, u32> &state_ids;
     u32 numStates;
+    const flat_set<NFAVertex> &unused;
     vector<NFAVertex> v_by_index;
     vector<CharReach> cr_by_index; /* pre alpha'ed */
     StateSet init;
@@ -449,9 +454,9 @@ public:
     StateSet acceptEod;
     StateSet toppable; /* states which are allowed to be on when a top arrives,
                         * triggered dfas only */
+    StateSet dead;
     map<u32, StateSet> squash_mask;
     bool prunable;
-    StateSet dead;
     array<u16, ALPHABET_SIZE> alpha;
     array<u16, ALPHABET_SIZE> unalpha;
     u16 alphasize;
@@ -460,140 +465,68 @@ public:
     u16 start_floating;
 };
 
-class Automaton_Graph {
-public:
-    typedef bitfield<NFA_STATE_LIMIT> StateSet;
-    typedef ue2::unordered_map<StateSet, dstate_id_t> StateMap;
+struct Big_Traits {
+    using StateSet = dynamic_bitset<>;
+    using StateMap = map<StateSet, dstate_id_t>;
 
-    Automaton_Graph(const ReportManager *rm_in, const NGHolder &graph_in,
-                    const ue2::unordered_map<NFAVertex, u32> &state_ids_in,
-                    bool single_trigger,
-                    const vector<vector<CharReach>> &triggers, bool prunable_in)
-        : rm(rm_in), graph(graph_in), state_ids(state_ids_in),
-          prunable(prunable_in) {
-        populateInit(graph, state_ids, &init, &initDS, &v_by_index);
-        populateAccepts(graph, state_ids, &accept, &acceptEod);
-
-        start_anchored = DEAD_STATE + 1;
-        if (initDS == init) {
-            start_floating = start_anchored;
-        } else if (initDS.any()) {
-            start_floating = start_anchored + 1;
-        } else {
-            start_floating = DEAD_STATE;
-        }
-
-        calculateAlphabet(graph, alpha, unalpha, &alphasize);
-        assert(alphasize <= ALPHABET_SIZE);
-
-        for (const auto &sq : findSquashers(graph)) {
-            NFAVertex v = sq.first;
-            u32 vert_id = graph[v].index;
-            squash.set(vert_id);
-            squash_mask[vert_id] = shrinkStateSet(sq.second);
-        }
-
-        cr_by_index = populateCR(graph, v_by_index, alpha);
-        if (is_triggered(graph)) {
-            dynamic_bitset<> temp(NFA_STATE_LIMIT);
-            markToppableStarts(graph, state_ids, single_trigger, triggers,
-                               &temp);
-            toppable = bitfield<NFA_STATE_LIMIT>(temp);
-        }
+    static StateSet init_states(u32 num) {
+        return StateSet(num);
     }
 
-private:
-    // Convert an NFAStateSet (as used by the squash code) into a StateSet
-    StateSet shrinkStateSet(const NFAStateSet &in) const {
-        StateSet out;
+    static StateSet copy_states(const dynamic_bitset<> &in, UNUSED u32 num) {
+        assert(in.size() == num);
+        return in;
+    }
+};
+
+class Automaton_Big : public Automaton_Base<Big_Traits> {
+public:
+    Automaton_Big(const ReportManager *rm_in, const NGHolder &graph_in,
+                  const flat_set<NFAVertex> &unused_in, bool single_trigger,
+                  const vector<vector<CharReach>> &triggers, bool prunable_in)
+        : Automaton_Base(rm_in, graph_in, unused_in, single_trigger, triggers,
+                         prunable_in) {}
+};
+
+struct Graph_Traits {
+    using StateSet = bitfield<NFA_STATE_LIMIT>;
+    using StateMap = ue2::unordered_map<StateSet, dstate_id_t>;
+
+    static StateSet init_states(UNUSED u32 num) {
+        assert(num <= NFA_STATE_LIMIT);
+        return StateSet();
+    }
+
+    static StateSet copy_states(const dynamic_bitset<> &in, u32 num) {
+        StateSet out = init_states(num);
         for (size_t i = in.find_first(); i != in.npos && i < out.size();
              i = in.find_next(i)) {
             out.set(i);
         }
         return out;
     }
+};
 
+class Automaton_Graph : public Automaton_Base<Graph_Traits> {
 public:
-    void transition(const StateSet &in, StateSet *next) {
-        transition_graph(*this, v_by_index, in, next);
-    }
-
-    const vector<StateSet> initial() {
-        vector<StateSet> rv(1, init);
-        if (start_floating != DEAD_STATE && start_floating != start_anchored) {
-            rv.push_back(initDS);
-        }
-        return rv;
-    }
-
-private:
-    void reports_i(const StateSet &in, bool eod, flat_set<ReportID> &rv) {
-        StateSet acc = in & (eod ? acceptEod : accept);
-        for (size_t i = acc.find_first(); i != StateSet::npos;
-             i = acc.find_next(i)) {
-            NFAVertex v = v_by_index[i];
-            DEBUG_PRINTF("marking report\n");
-            const auto &my_reports = graph[v].reports;
-            rv.insert(my_reports.begin(), my_reports.end());
-        }
-    }
-
-public:
-    void reports(const StateSet &in, flat_set<ReportID> &rv) {
-        reports_i(in, false, rv);
-    }
-    void reportsEod(const StateSet &in, flat_set<ReportID> &rv) {
-        reports_i(in, true, rv);
-    }
-
-    bool canPrune(const flat_set<ReportID> &test_reports) const {
-        if (!rm || !prunable || !canPruneEdgesFromAccept(*rm, graph)) {
-            return false;
-        }
-        return allExternalReports(*rm, test_reports);
-    }
-
-private:
-    const ReportManager *rm;
-public:
-    const NGHolder &graph;
-    const ue2::unordered_map<NFAVertex, u32> &state_ids;
-    vector<NFAVertex> v_by_index;
-    vector<CharReach> cr_by_index; /* pre alpha'ed */
-    StateSet init;
-    StateSet initDS;
-    StateSet squash; /* states which allow us to mask out other states */
-    StateSet accept;
-    StateSet acceptEod;
-    StateSet toppable; /* states which are allowed to be on when a top arrives,
-                        * triggered dfas only */
-    map<u32, StateSet> squash_mask;
-    bool prunable;
-    StateSet dead;
-    array<u16, ALPHABET_SIZE> alpha;
-    array<u16, ALPHABET_SIZE> unalpha;
-    u16 alphasize;
-
-    u16 start_anchored;
-    u16 start_floating;
+    Automaton_Graph(const ReportManager *rm_in, const NGHolder &graph_in,
+                  const flat_set<NFAVertex> &unused_in, bool single_trigger,
+                  const vector<vector<CharReach>> &triggers, bool prunable_in)
+        : Automaton_Base(rm_in, graph_in, unused_in, single_trigger, triggers,
+                         prunable_in) {}
 };
 
 } // namespace
 
-unique_ptr<raw_dfa> buildMcClellan(const NGHolder &g, const ReportManager *rm,
-                                   bool single_trigger,
+unique_ptr<raw_dfa> buildMcClellan(const NGHolder &graph,
+                                   const ReportManager *rm, bool single_trigger,
                                    const vector<vector<CharReach>> &triggers,
                                    const Grey &grey, bool finalChance) {
     if (!grey.allowMcClellan) {
         return nullptr;
     }
 
-    // Construct a mutable copy of the graph so that we can drop unused starts.
-    auto g_copy = cloneHolder(g);
-    NGHolder &graph = *g_copy;
-
-    auto state_ids = numberStates(graph);
-    dropUnusedStarts(graph, state_ids);
+    auto unused = findUnusedStates(graph);
 
     DEBUG_PRINTF("attempting to build ?%d? mcclellan\n", (int)graph.kind);
     assert(allMatchStatesHaveReports(graph));
@@ -620,7 +553,7 @@ unique_ptr<raw_dfa> buildMcClellan(const NGHolder &g, const ReportManager *rm,
     if (numStates <= NFA_STATE_LIMIT) {
         /* Fast path. Automaton_Graph uses a bitfield internally to represent
          * states and is quicker than Automaton_Big. */
-        Automaton_Graph n(rm, graph, state_ids, single_trigger, triggers,
+        Automaton_Graph n(rm, graph, unused, single_trigger, triggers,
                           prunable);
         if (determinise(n, rdfa->states, state_limit)) {
             DEBUG_PRINTF("state limit exceeded\n");
@@ -633,8 +566,7 @@ unique_ptr<raw_dfa> buildMcClellan(const NGHolder &g, const ReportManager *rm,
         rdfa->alpha_remap = n.alpha;
     } else {
         /* Slow path. Too many states to use Automaton_Graph. */
-        Automaton_Big n(rm, graph, state_ids, single_trigger, triggers,
-                        prunable);
+        Automaton_Big n(rm, graph, unused, single_trigger, triggers, prunable);
         if (determinise(n, rdfa->states, state_limit)) {
             DEBUG_PRINTF("state limit exceeded\n");
             return nullptr; /* over state limit */
diff --git a/src/nfagraph/ng_mcclellan_internal.h b/src/nfagraph/ng_mcclellan_internal.h
index 13d32aa4..22fcf01e 100644
--- a/src/nfagraph/ng_mcclellan_internal.h
+++ b/src/nfagraph/ng_mcclellan_internal.h
@@ -64,8 +64,7 @@ void getFullTransitionFromState(const raw_dfa &n, u16 state,
                                 u16 *out_table);
 
 /** produce a map of states on which it is valid to receive tops */
-void markToppableStarts(const NGHolder &g,
-                        const ue2::unordered_map<NFAVertex, u32> &state_ids,
+void markToppableStarts(const NGHolder &g, const flat_set<NFAVertex> &unused,
                         bool single_trigger,
                         const std::vector<std::vector<CharReach>> &triggers,
                         boost::dynamic_bitset<> *out);
@@ -76,7 +75,7 @@ void transition_graph(autom &nfa, const std::vector<NFAVertex> &vByStateId,
                       typename autom::StateSet *next) {
     typedef typename autom::StateSet StateSet;
     const NGHolder &graph = nfa.graph;
-    const auto &state_ids = nfa.state_ids;
+    const auto &unused = nfa.unused;
     const auto &alpha = nfa.alpha;
     const StateSet &squash = nfa.squash;
     const std::map<u32, StateSet> &squash_mask = nfa.squash_mask;
@@ -94,7 +93,7 @@ void transition_graph(autom &nfa, const std::vector<NFAVertex> &vByStateId,
         NFAVertex u = vByStateId[i];
 
         for (const auto &v : adjacent_vertices_range(u, graph)) {
-            if (state_ids.at(v) == NO_STATE) {
+            if (contains(unused, v)) {
                 continue;
             }
             succ.set(graph[v].index);
diff --git a/src/nfagraph/ng_misc_opt.h b/src/nfagraph/ng_misc_opt.h
index c0e24da5..4955c7af 100644
--- a/src/nfagraph/ng_misc_opt.h
+++ b/src/nfagraph/ng_misc_opt.h
@@ -60,8 +60,8 @@ struct BoundedRepeatSummary {
 bool improveGraph(NGHolder &g, som_type som);
 
 /** Sometimes the reach of a vertex is greater than it needs to be to reduce
- * stop chars for the benefit of the rest of our code base (accel, sidecar,
- * etc). In these circumstances, we can treat the reach as the smaller one as
+ * stop chars for the benefit of the rest of our code base (accel, etc). In
+ * these circumstances, we can treat the reach as the smaller one as
  * the graphs are equivalent. */
 CharReach reduced_cr(NFAVertex v, const NGHolder &g,
         const std::map<NFAVertex, BoundedRepeatSummary> &br_cyclic);
diff --git a/src/nfagraph/ng_prefilter.cpp b/src/nfagraph/ng_prefilter.cpp
index 54aeb28a..c2b9eea9 100644
--- a/src/nfagraph/ng_prefilter.cpp
+++ b/src/nfagraph/ng_prefilter.cpp
@@ -80,6 +80,10 @@ static const size_t BOUNDED_REPEAT_COUNT = 4;
 /** Scoring penalty for boundary regions. */
 static const size_t PENALTY_BOUNDARY = 32;
 
+/** Regions with max bounds greater than this value will have their max bound
+ * replaced with inf. */
+static const size_t MAX_REPLACE_BOUND = 10000;
+
 namespace {
 
 /** Information describing a region. */
@@ -158,7 +162,7 @@ void markBoundaryRegions(const NGHolder &h,
         }
         u32 id = region_map.at(v);
 
-        map<u32, RegionInfo>::iterator ri = regions.find(id);
+        auto ri = regions.find(id);
         if (ri == regions.end()) {
             continue; // Not tracking this region as it's too small.
         }
@@ -176,16 +180,14 @@ map<u32, RegionInfo> findRegionInfo(const NGHolder &h,
             continue;
         }
         u32 id = region_map.at(v);
-        RegionInfo &ri = regions.insert(
-                    make_pair(id, RegionInfo(id))).first->second;
+        RegionInfo &ri = regions.emplace(id, RegionInfo(id)).first->second;
         ri.vertices.push_back(v);
         ri.reach |= h[v].char_reach;
     }
 
     // There's no point tracking more information about regions that we won't
     // consider replacing, so we remove them from the region map.
-    for (map<u32, RegionInfo>::iterator it = regions.begin();
-         it != regions.end();) {
+    for (auto it = regions.begin(); it != regions.end();) {
         if (it->second.vertices.size() < MIN_REPLACE_VERTICES) {
             regions.erase(it++);
         } else {
@@ -217,7 +219,10 @@ void copyInEdges(NGHolder &g, NFAVertex from, NFAVertex to,
         if (contains(rverts, u)) {
             continue;
         }
-        if (edge(u, to, g).second) {
+
+        // Check with edge_by_target to cope with predecessors with large
+        // fan-out.
+        if (edge_by_target(u, to, g).second) {
             continue;
         }
 
@@ -250,17 +255,27 @@ void replaceRegion(NGHolder &g, const RegionInfo &ri,
     assert(ri.vertices.size() >= MIN_REPLACE_VERTICES);
     assert(ri.minWidth.is_finite());
 
+    depth minWidth = ri.minWidth;
+    depth maxWidth = ri.maxWidth;
+
+    if (maxWidth > depth(MAX_REPLACE_BOUND)) {
+        DEBUG_PRINTF("using inf instead of large bound %s\n",
+                     maxWidth.str().c_str());
+        maxWidth = depth::infinity();
+    }
+
     size_t replacementSize;
-    if (ri.minWidth == ri.maxWidth || ri.maxWidth.is_infinite()) {
-        replacementSize = ri.minWidth; // {N} or {N,}
+    if (minWidth == maxWidth || maxWidth.is_infinite()) {
+        replacementSize = minWidth; // {N} or {N,}
     } else {
-        replacementSize = ri.maxWidth; // {N,M} case
+        replacementSize = maxWidth; // {N,M} case
     }
 
     DEBUG_PRINTF("orig size %zu, replace size %zu\n", ri.vertices.size(),
                  replacementSize);
 
-    deque<NFAVertex> verts;
+    vector<NFAVertex> verts;
+    verts.reserve(replacementSize);
     for (size_t i = 0; i < replacementSize; i++) {
         NFAVertex v = add_vertex(g);
         g[v].char_reach = ri.reach;
@@ -270,7 +285,7 @@ void replaceRegion(NGHolder &g, const RegionInfo &ri,
         verts.push_back(v);
     }
 
-    if (ri.maxWidth.is_infinite()) {
+    if (maxWidth.is_infinite()) {
         add_edge(verts.back(), verts.back(), g);
     }
 
@@ -360,7 +375,8 @@ void prefilterReductions(NGHolder &h, const CompileContext &cc) {
         return;
     }
 
-    DEBUG_PRINTF("graph with %zu vertices\n", num_vertices(h));
+    DEBUG_PRINTF("before: graph with %zu vertices, %zu edges\n",
+                 num_vertices(h), num_edges(h));
 
     h.renumberVertices();
     h.renumberEdges();
@@ -369,6 +385,10 @@ void prefilterReductions(NGHolder &h, const CompileContext &cc) {
 
     h.renumberVertices();
     h.renumberEdges();
+
+    DEBUG_PRINTF("after: graph with %zu vertices, %zu edges\n",
+                 num_vertices(h), num_edges(h));
+
 }
 
 } // namespace ue2
diff --git a/src/nfagraph/ng_puff.cpp b/src/nfagraph/ng_puff.cpp
index 501d8f7b..540f4859 100644
--- a/src/nfagraph/ng_puff.cpp
+++ b/src/nfagraph/ng_puff.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -270,12 +270,16 @@ void constructPuff(NGHolder &g, const NFAVertex a, const NFAVertex puffv,
     DEBUG_PRINTF("constructing Puff for report %u\n", report);
     DEBUG_PRINTF("a = %u\n", g[a].index);
 
+    const Report &puff_report = rm.getReport(report);
+    const bool simple_exhaust = isSimpleExhaustible(puff_report);
+
     const bool pureAnchored = a == g.start && singleStart(g);
     if (!pureAnchored) {
         if (a == g.startDs || a == g.start) {
             DEBUG_PRINTF("add outfix ar(false)\n");
 
-            raw_puff rp(width, unbounded, report, cr, auto_restart);
+            raw_puff rp(width, unbounded, report, cr, auto_restart,
+                        simple_exhaust);
             rose.addOutfix(rp);
             return;
         }
@@ -289,7 +293,7 @@ void constructPuff(NGHolder &g, const NFAVertex a, const NFAVertex puffv,
         u32 squashDistance = allowedSquashDistance(cr, width, g, puffv,
                                                    prefilter);
 
-        Report ir = makeRoseTrigger(event, squashDistance);
+        Report ir = makeMpvTrigger(event, squashDistance);
         /* only need to trigger once if floatingUnboundedDot */
         bool floatingUnboundedDot = unbounded && cr.all() && !fixed_depth;
         if (floatingUnboundedDot) {
@@ -300,7 +304,7 @@ void constructPuff(NGHolder &g, const NFAVertex a, const NFAVertex puffv,
     } else {
         DEBUG_PRINTF("add outfix ar(%d)\n", (int)auto_restart);
         assert(!auto_restart || unbounded);
-        raw_puff rp(width, unbounded, report, cr, auto_restart);
+        raw_puff rp(width, unbounded, report, cr, auto_restart, simple_exhaust);
         rose.addOutfix(rp);
     }
 }
diff --git a/src/nfagraph/ng_restructuring.cpp b/src/nfagraph/ng_restructuring.cpp
index 70344356..09abf775 100644
--- a/src/nfagraph/ng_restructuring.cpp
+++ b/src/nfagraph/ng_restructuring.cpp
@@ -281,6 +281,17 @@ void dropUnusedStarts(NGHolder &g, ue2::unordered_map<NFAVertex, u32> &states) {
     }
 }
 
+flat_set<NFAVertex> findUnusedStates(const NGHolder &g) {
+    flat_set<NFAVertex> dead;
+    if (startIsRedundant(g)) {
+        dead.insert(g.start);
+    }
+    if (proper_out_degree(g.startDs, g) == 0) {
+        dead.insert(g.startDs);
+    }
+    return dead;
+}
+
 /** Construct a reversed copy of an arbitrary NGHolder, mapping starts to
  * accepts. */
 void reverseHolder(const NGHolder &g_in, NGHolder &g) {
diff --git a/src/nfagraph/ng_restructuring.h b/src/nfagraph/ng_restructuring.h
index ce95b96c..5e244bf6 100644
--- a/src/nfagraph/ng_restructuring.h
+++ b/src/nfagraph/ng_restructuring.h
@@ -81,6 +81,13 @@ u32 countStates(const NGHolder &g,
 /** Optimisation: drop unnecessary start states. */
 void dropUnusedStarts(NGHolder &g, ue2::unordered_map<NFAVertex, u32> &states);
 
+/**
+ * \brief Returns a set of vertices that will not participate in an
+ * implementation (NFA, DFA etc) of this graph. For example, starts with no
+ * successors.
+ */
+flat_set<NFAVertex> findUnusedStates(const NGHolder &g);
+
 } // namespace ue2
 
 #endif
diff --git a/src/nfagraph/ng_rose.cpp b/src/nfagraph/ng_rose.cpp
index f706e858..3015af4c 100644
--- a/src/nfagraph/ng_rose.cpp
+++ b/src/nfagraph/ng_rose.cpp
@@ -1505,16 +1505,10 @@ bool splitRoseEdge(RoseInGraph &ig, const VertLitInfo &split,
 }
 
 static
-bool isStarCliche(const NGHolder &g, const ue2_literal &succ_lit,
-                  const Grey &grey, CharReach *escapes_out) {
+bool isStarCliche(const NGHolder &g) {
     DEBUG_PRINTF("checking graph with %zu vertices\n", num_vertices(g));
 
     bool nonspecials_seen = false;
-    CharReach escapes;
-
-    // Escapes are only available if we have the Sidecar engine available to
-    // implement them.
-    const u32 max_escapes = grey.allowSidecar ? MAX_ESCAPE_CHARS : 0;
 
     for (auto v : vertices_range(g)) {
         if (is_special(v, g)) {
@@ -1526,8 +1520,7 @@ bool isStarCliche(const NGHolder &g, const ue2_literal &succ_lit,
         }
         nonspecials_seen = true;
 
-        escapes = ~g[v].char_reach;
-        if (escapes.count() > max_escapes) {
+        if (!g[v].char_reach.all()) {
             return false;
         }
 
@@ -1547,14 +1540,6 @@ bool isStarCliche(const NGHolder &g, const ue2_literal &succ_lit,
         return false;
     }
 
-    /* we need to check that succ lit does not intersect with the escapes. */
-    for (const auto &c : succ_lit) {
-        if ((escapes & c).any()) {
-            return false;
-        }
-    }
-
-    *escapes_out = escapes;
     return true;
 }
 
@@ -1620,16 +1605,13 @@ void processInfixes(RoseInGraph &ig, const CompileContext &cc) {
 
         if (delay != max_allowed_delay) {
             restoreTrailingLiteralStates(*h_new, lit2, delay);
-            delay = removeTrailingLiteralStates(*h_new, lit2,
-                                                max_allowed_delay);
+            delay = removeTrailingLiteralStates(*h_new, lit2, max_allowed_delay);
         }
 
-        CharReach escapes;
-        if (isStarCliche(*h_new, lit2, cc.grey, &escapes)) {
+        if (isStarCliche(*h_new)) {
             DEBUG_PRINTF("is a X star!\n");
             ig[e].graph.reset();
             ig[e].graph_lag = 0;
-            ig[e].escapes = escapes;
         } else {
             ig[e].graph = move(h_new);
             ig[e].graph_lag = delay;
@@ -2410,7 +2392,6 @@ static
 void makeNocaseWithPrefixMask(RoseInGraph &g, RoseInVertex v) {
     for (const auto &e : in_edges_range(v, g)) {
         const RoseInVertex u = source(e, g);
-        CharReach &escapes = g[e].escapes;
 
         if (!g[e].graph) {
             g[e].graph = make_shared<NGHolder>(whatRoseIsThis(g, e));
@@ -2420,17 +2401,13 @@ void makeNocaseWithPrefixMask(RoseInGraph &g, RoseInVertex v) {
             assert(!g[e].maxBound || g[e].maxBound == ROSE_BOUND_INF);
 
             if (g[u].type == RIV_START) {
-                assert(escapes.none());
                 add_edge(h.startDs, h.accept, h);
                 h[h.startDs].reports.insert(0);
             } else if (g[e].maxBound == ROSE_BOUND_INF) {
                 add_edge(h.start, h.accept, h);
                 NFAVertex ds = add_vertex(h);
 
-                // Cyclic vertex which takes over handling the escapes inside
-                // the prefix graph.
-                h[ds].char_reach = ~escapes;
-                escapes.clear();
+                h[ds].char_reach = CharReach::dot();
 
                 add_edge(h.start, ds, h);
                 add_edge(ds, ds, h);
@@ -2438,7 +2415,6 @@ void makeNocaseWithPrefixMask(RoseInGraph &g, RoseInVertex v) {
                 h[h.start].reports.insert(0);
                 h[ds].reports.insert(0);
             } else {
-                assert(escapes.none());
                 add_edge(h.start, h.accept, h);
                 h[h.start].reports.insert(0);
             }
diff --git a/src/nfagraph/ng_som.cpp b/src/nfagraph/ng_som.cpp
index f26b62aa..03a612a0 100644
--- a/src/nfagraph/ng_som.cpp
+++ b/src/nfagraph/ng_som.cpp
@@ -445,8 +445,9 @@ void replaceTempSomSlot(ReportManager &rm, NGHolder &g, u32 real_slot) {
 }
 
 static
-void setPrefixReports(ReportManager &rm, NGHolder &g, u8 ir_type, u32 som_loc,
-                      const vector<DepthMinMax> &depths, bool prefix_by_rev) {
+void setPrefixReports(ReportManager &rm, NGHolder &g, ReportType ir_type,
+                      u32 som_loc, const vector<DepthMinMax> &depths,
+                      bool prefix_by_rev) {
     Report ir = makeCallback(0U, 0);
     ir.type = ir_type;
     ir.onmatch = som_loc;
@@ -470,7 +471,7 @@ void setPrefixReports(ReportManager &rm, NGHolder &g, u8 ir_type, u32 som_loc,
 }
 
 static
-void updatePrefixReports(ReportManager &rm, NGHolder &g, u8 ir_type) {
+void updatePrefixReports(ReportManager &rm, NGHolder &g, ReportType ir_type) {
     /* update the som action on the prefix report */
     for (auto v : inv_adjacent_vertices_range(g.accept, g)) {
         auto &reports = g[v].reports;
@@ -555,7 +556,8 @@ bool finalRegion(const NGHolder &g,
 
 static
 void replaceExternalReportsWithSomRep(ReportManager &rm, NGHolder &g,
-                                      NFAVertex v, u8 ir_type, u64a param) {
+                                      NFAVertex v, ReportType ir_type,
+                                      u64a param) {
     assert(!g[v].reports.empty());
 
     flat_set<ReportID> r_new;
@@ -2409,6 +2411,33 @@ bool splitOffBestLiteral(const NGHolder &g,
     return true;
 }
 
+/**
+ * Replace the given graph's EXTERNAL_CALLBACK reports with
+ * EXTERNAL_CALLBACK_SOM_PASS reports.
+ */
+void makeReportsSomPass(ReportManager &rm, NGHolder &g) {
+    for (const auto &v : vertices_range(g)) {
+        const auto &reports = g[v].reports;
+        if (reports.empty()) {
+            continue;
+        }
+
+        flat_set<ReportID> new_reports;
+        for (const ReportID &id : reports) {
+            const Report &report = rm.getReport(id);
+            if (report.type != EXTERNAL_CALLBACK) {
+                new_reports.insert(id);
+                continue;
+            }
+            Report report2 = report;
+            report2.type = EXTERNAL_CALLBACK_SOM_PASS;
+            new_reports.insert(rm.getInternalId(report2));
+        }
+
+        g[v].reports = new_reports;
+    }
+}
+
 static
 bool doLitHaigSom(NG &ng, NGHolder &g, som_type som) {
     ue2_literal lit;
@@ -2431,6 +2460,8 @@ bool doLitHaigSom(NG &ng, NGHolder &g, som_type som) {
 
     assert(lit.length() <= MAX_MASK2_WIDTH || !mixed_sensitivity(lit));
 
+    makeReportsSomPass(ng.rm, *rhs);
+
     dumpHolder(*rhs, 91, "lithaig_rhs", ng.cc.grey);
 
     vector<vector<CharReach> > triggers;
@@ -2493,6 +2524,8 @@ bool doHaigLitHaigSom(NG &ng, NGHolder &g,
         return false; /* TODO: handle */
     }
 
+    makeReportsSomPass(ng.rm, *rhs);
+
     dumpHolder(*lhs, 92, "haiglithaig_lhs", ng.cc.grey);
     dumpHolder(*rhs, 93, "haiglithaig_rhs", ng.cc.grey);
 
@@ -2628,6 +2661,8 @@ bool doMultiLitHaigSom(NG &ng, NGHolder &g, som_type som) {
         return false;
     }
 
+    makeReportsSomPass(ng.rm, *rhs);
+
     dumpHolder(*rhs, 91, "lithaig_rhs", ng.cc.grey);
 
     vector<vector<CharReach>> triggers;
diff --git a/src/nfagraph/ng_som.h b/src/nfagraph/ng_som.h
index 0ae2f17b..70710945 100644
--- a/src/nfagraph/ng_som.h
+++ b/src/nfagraph/ng_som.h
@@ -72,6 +72,8 @@ sombe_rv doSom(NG &ng, NGHolder &h, const NGWrapper &w, u32 comp_id,
 sombe_rv doSomWithHaig(NG &ng, NGHolder &h, const NGWrapper &w, u32 comp_id,
                        som_type som);
 
+void makeReportsSomPass(ReportManager &rm, NGHolder &g);
+
 } // namespace ue2
 
 #endif // NG_SOM_H
diff --git a/src/nfagraph/ng_som_util.cpp b/src/nfagraph/ng_som_util.cpp
index a0829451..676fb523 100644
--- a/src/nfagraph/ng_som_util.cpp
+++ b/src/nfagraph/ng_som_util.cpp
@@ -186,8 +186,7 @@ bool somMayGoBackwards(NFAVertex u, const NGHolder &g,
         return cache.smgb[u];
     }
 
-    DEBUG_PRINTF("checking if som can go backwards on %u\n",
-                  g[u].index);
+    DEBUG_PRINTF("checking if som can go backwards on %u\n", g[u].index);
 
     set<NFAEdge> be;
     BackEdges<set<NFAEdge>> backEdgeVisitor(be);
@@ -224,6 +223,7 @@ bool somMayGoBackwards(NFAVertex u, const NGHolder &g,
     NGHolder c_g;
     cloneHolder(c_g, g, &orig_to_copy);
 
+    /* treat virtual starts as unconditional - wire to startDs instead */
     for (NFAVertex v : vertices_range(g)) {
         if (!is_virtual_start(v, g)) {
             continue;
@@ -236,6 +236,7 @@ bool somMayGoBackwards(NFAVertex u, const NGHolder &g,
         clear_vertex(c_v, c_g);
     }
 
+    /* treat u as the only accept state */
     NFAVertex c_u = orig_to_copy[u];
     clear_in_edges(c_g.acceptEod, c_g);
     add_edge(c_g.accept, c_g.acceptEod, c_g);
@@ -256,7 +257,9 @@ bool somMayGoBackwards(NFAVertex u, const NGHolder &g,
         }
         for (auto v : adjacent_vertices_range(t, g)) {
             if (contains(u_succ, v)) {
-                add_edge(orig_to_copy[t], c_g.accept, c_g);
+                /* due to virtual starts being aliased with normal starts in the
+                 * copy of the graph, we may have already added the edges. */
+                add_edge_if_not_present(orig_to_copy[t], c_g.accept, c_g);
                 break;
             }
         }
diff --git a/src/nfagraph/ng_split.cpp b/src/nfagraph/ng_split.cpp
index 3a66b2fa..42157e1e 100644
--- a/src/nfagraph/ng_split.cpp
+++ b/src/nfagraph/ng_split.cpp
@@ -113,6 +113,7 @@ void splitLHS(const NGHolder &base, const vector<NFAVertex> &pivots,
         lhs->kind = NFA_INFIX;
         break;
     case NFA_REV_PREFIX:
+    case NFA_OUTFIX_RAW:
         assert(0);
         break;
     }
@@ -154,6 +155,7 @@ void splitRHS(const NGHolder &base, const vector<NFAVertex> &pivots,
         rhs->kind = NFA_SUFFIX;
         break;
     case NFA_REV_PREFIX:
+    case NFA_OUTFIX_RAW:
         assert(0);
         break;
     }
diff --git a/src/nfagraph/ng_squash.cpp b/src/nfagraph/ng_squash.cpp
index 04afda81..dd3693e5 100644
--- a/src/nfagraph/ng_squash.cpp
+++ b/src/nfagraph/ng_squash.cpp
@@ -319,6 +319,44 @@ void findDerivedSquashers(const NGHolder &g, const vector<NFAVertex> &vByIndex,
     }
 }
 
+/* If there are redundant states in the graph, it may be possible for two sibling
+ * .* states to try to squash each other -- which should be prevented
+ *
+ * Note: this situation should only happen if ng_equivalence has not been run.
+ */
+static
+void clearMutualSquashers(const NGHolder &g, const vector<NFAVertex> &vByIndex,
+                          map<NFAVertex, NFAStateSet> &squash) {
+    for (auto it = squash.begin(); it != squash.end();) {
+        NFAVertex a = it->first;
+        u32 a_index = g[a].index;
+
+        NFAStateSet a_squash = ~it->second;  /* default is mask of survivors */
+        for (NFAStateSet::size_type b_index = a_squash.find_first();
+             b_index != a_squash.npos; b_index = a_squash.find_next(b_index)) {
+            assert(b_index != a_index);
+            NFAVertex b = vByIndex[b_index];
+            if (!contains(squash, b)) {
+                continue;
+            }
+            if (!squash[b].test(a_index)) {
+                /* b and a squash each other, prevent this */
+                DEBUG_PRINTF("removing mutual squash %u %zu\n",
+                             a_index, b_index);
+                squash[b].set(a_index);
+                it->second.set(b_index);
+            }
+        }
+
+        if (it->second.all()) {
+            DEBUG_PRINTF("%u is no longer an effictive squash state\n", a_index);
+            it = squash.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
 map<NFAVertex, NFAStateSet> findSquashers(const NGHolder &g, som_type som) {
     map<NFAVertex, NFAStateSet> squash;
 
@@ -460,6 +498,8 @@ map<NFAVertex, NFAStateSet> findSquashers(const NGHolder &g, som_type som) {
     findDerivedSquashers(g, vByIndex, pdom_tree, initStates, &squash, som,
                          som_depths, region_map, cache);
 
+    clearMutualSquashers(g, vByIndex, squash);
+
     return squash;
 }
 
diff --git a/src/nfagraph/ng_uncalc_components.cpp b/src/nfagraph/ng_uncalc_components.cpp
index 47e3ff08..abba09f9 100644
--- a/src/nfagraph/ng_uncalc_components.cpp
+++ b/src/nfagraph/ng_uncalc_components.cpp
@@ -486,53 +486,49 @@ void buildNfaMergeQueue(const vector<NGHolder *> &cluster,
     }
 }
 
-/** True if the graphs have compatible starts for merging, i.e. they are NOT
- * both vacuous with different reports on the starts. */
+/**
+ * True if the graphs have mergeable starts.
+ *
+ * Nowadays, this means that any vacuous edges must have the same tops. In
+ * addition, mixed-accept cases need to have matching reports.
+ */
 static
 bool mergeableStarts(const NGHolder &h1, const NGHolder &h2) {
-    bool vac1 = isVacuous(h1), vac2 = isVacuous(h2);
-
-    // Safety tests: reports should be empty on non-vacuous graphs.
-    if (!vac1) {
-        assert(h1[h1.start].reports.empty());
-        assert(h1[h1.startDs].reports.empty());
-    }
-    if (!vac2) {
-        assert(h2[h2.start].reports.empty());
-        assert(h2[h2.startDs].reports.empty());
+    if (!isVacuous(h1) || !isVacuous(h2)) {
+        return true;
     }
 
-    if (vac1 && vac2) {
-        // Graphs must have the same reports on their starts to be mergeable
-        // (and top on start->accept).
-        if (h1[h1.start].reports
-            != h2[h2.start].reports) {
+    // Vacuous edges from startDs should not occur: we have better ways to
+    // implement true dot-star relationships. Just in case they do, ban them
+    // from being merged unless they have identical reports.
+    if (is_match_vertex(h1.startDs, h1) || is_match_vertex(h2.startDs, h2)) {
+        assert(0);
+        return false;
+    }
+
+    // If both graphs have edge (start, accept), the tops must match.
+    auto e1_accept = edge(h1.start, h1.accept, h1);
+    auto e2_accept = edge(h2.start, h2.accept, h2);
+    if (e1_accept.second && e2_accept.second &&
+        h1[e1_accept.first].top != h2[e2_accept.first].top) {
+        return false;
+    }
+
+    // If both graphs have edge (start, acceptEod), the tops must match.
+    auto e1_eod = edge(h1.start, h1.acceptEod, h1);
+    auto e2_eod = edge(h2.start, h2.acceptEod, h2);
+    if (e1_eod.second && e2_eod.second &&
+        h1[e1_eod.first].top != h2[e2_eod.first].top) {
+        return false;
+    }
+
+    // If one graph has an edge to accept and the other has an edge to
+    // acceptEod, the reports must match for the merge to be safe.
+    if ((e1_accept.second && e2_eod.second) ||
+        (e2_accept.second && e1_eod.second)) {
+        if (h1[h1.start].reports != h2[h2.start].reports) {
             return false;
         }
-
-        if (h1[h1.startDs].reports
-            != h2[h2.startDs].reports) {
-            return false;
-        }
-
-        pair<NFAEdge, bool> e1, e2;
-        e1 = edge(h1.start, h1.accept, h1);
-        e2 = edge(h2.start, h2.accept, h2);
-        if (e1.second || e2.second) {
-            if (e1.second && e2.second &&
-                h1[e1.first].top != h2[e2.first].top) {
-                return false;
-            }
-        }
-
-        e1 = edge(h1.start, h1.acceptEod, h1);
-        e2 = edge(h2.start, h2.acceptEod, h2);
-        if (e1.second || e2.second) {
-            if (e1.second && e2.second &&
-                h1[e1.first].top != h2[e2.first].top) {
-                return false;
-            }
-        }
     }
 
     return true;
@@ -545,20 +541,14 @@ bool mergeNfaPair(NGHolder &ga, NGHolder &gb, const ReportManager *rm,
     auto a_state_ids = numberStates(ga);
     auto b_state_ids = numberStates(gb);
 
-    // At the moment, since our vertices can only have one report ID each,
-    // we must ensure that our start vertices have the same report ID,
-    // otherwise they can't be merged. This happens in vacuous NFAs, used
-    // by Rose.
-    // XXX: the multi-top code has this limitation, too.
+    // Vacuous NFAs require special checks on their starts to ensure that tops
+    // match, and that reports match for mixed-accept cases.
     if (!mergeableStarts(ga, gb)) {
         DEBUG_PRINTF("starts aren't mergeable\n");
         return false;
     }
 
-    // NOTE: states must be numbered already.
-
     u32 cpl = commonPrefixLength(ga, a_state_ids, gb, b_state_ids);
-
     if (!shouldMerge(gb, b_state_ids, ga, a_state_ids, cpl, rm, cc)) {
         return false;
     }
diff --git a/src/parser/ComponentCondReference.h b/src/parser/ComponentCondReference.h
index 9d53b2a8..c0ee9ac3 100644
--- a/src/parser/ComponentCondReference.h
+++ b/src/parser/ComponentCondReference.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -46,9 +46,9 @@ class ComponentCondReference : public ComponentSequence {
     friend class ReferenceVisitor;
     friend class PrintVisitor;
 public:
-    ComponentCondReference(unsigned ref);
-    ComponentCondReference(const std::string &name);
-    ComponentCondReference(std::unique_ptr<Component> c);
+    explicit ComponentCondReference(unsigned ref);
+    explicit ComponentCondReference(const std::string &name);
+    explicit ComponentCondReference(std::unique_ptr<Component> c);
 
     ~ComponentCondReference() override;
     ComponentCondReference *clone() const override;
diff --git a/src/parser/ComponentRepeat.cpp b/src/parser/ComponentRepeat.cpp
index 8cd88372..ff02703c 100644
--- a/src/parser/ComponentRepeat.cpp
+++ b/src/parser/ComponentRepeat.cpp
@@ -87,8 +87,7 @@ ComponentRepeat::ComponentRepeat(const ComponentRepeat &other)
       type(other.type), sub_comp(unique_ptr<Component>(other.sub_comp->clone())),
       m_min(other.m_min), m_max(other.m_max),
       m_firsts(other.m_firsts), m_lasts(other.m_lasts),
-      posFirst(other.posFirst), posLast(other.posLast),
-      firsts_cache(other.firsts_cache) {}
+      posFirst(other.posFirst), posLast(other.posLast) {}
 
 bool ComponentRepeat::empty() const {
     return m_min == 0 || sub_comp->empty();
@@ -175,14 +174,24 @@ void ComponentRepeat::notePositions(GlushkovBuildState &bs) {
     }
 
     recordPosBounds(posFirst, bs.getBuilder().numVertices());
-    precalc_firsts(); /* ComponentRepeat requires firsts to be calculated ahead
-                       * of time and cached due to expense */
+
+    // Each optional repeat has an epsilon at the end of its firsts list.
+    for (u32 i = m_min; i < m_firsts.size(); i++) {
+        m_firsts[i].push_back(GlushkovBuildState::POS_EPSILON);
+    }
+
 }
 
 vector<PositionInfo> ComponentRepeat::first() const {
-    DEBUG_PRINTF("firsts = %s\n", dumpPositions(firsts_cache.begin(),
-                                                firsts_cache.end()).c_str());
-    return firsts_cache;
+    if (!m_max) {
+        return {};
+    }
+
+    assert(!m_firsts.empty()); // notePositions should already have run
+    const vector<PositionInfo> &firsts = m_firsts.front();
+    DEBUG_PRINTF("firsts = %s\n",
+                 dumpPositions(begin(firsts), end(firsts)).c_str());
+    return firsts;
 }
 
 void ComponentRepeat::buildFollowSet(GlushkovBuildState &bs,
@@ -209,7 +218,7 @@ void ComponentRepeat::buildFollowSet(GlushkovBuildState &bs,
         }
     }
 
-    wireRepeats(bs, lastPos);
+    wireRepeats(bs);
 
     DEBUG_PRINTF("leave\n");
 }
@@ -279,26 +288,24 @@ vector<PositionInfo> ComponentRepeat::last() const {
     assert(!m_firsts.empty()); // notePositions should already have run
     assert(!m_lasts.empty());
 
-    // Optimisation: when we're not maintaining edge priorities, handling
-    // optional repeats has been taken care of by our FIRSTS. Thus, only
-    // the last mandatory repeat and (if different) the last optional
-    // repeat contributes to lasts.
-    if (m_min) {
-        const vector<PositionInfo> &l = m_lasts[m_min - 1];
-        lasts.insert(lasts.end(), l.begin(), l.end());
-    }
+    const auto &l = m_min ? m_lasts[m_min - 1] : m_lasts[0];
+    lasts.insert(lasts.end(), l.begin(), l.end());
+
     if (!m_min || m_min != m_lasts.size()) {
         lasts.insert(lasts.end(), m_lasts.back().begin(), m_lasts.back().end());
     }
+
+    DEBUG_PRINTF("lasts = %s\n",
+                 dumpPositions(lasts.begin(), lasts.end()).c_str());
     return lasts;
 }
 
-void ComponentRepeat::wireRepeats(GlushkovBuildState &bs,
-                                      const vector<PositionInfo> &lastPos) {
+void ComponentRepeat::wireRepeats(GlushkovBuildState &bs) {
     /* note: m_lasts[0] already valid */
     u32 copies = m_firsts.size();
     const bool isEmpty = sub_comp->empty();
-    const vector<PositionInfo> &optLasts = m_min ? m_lasts[m_min - 1] : lastPos;
+    const vector<PositionInfo> &optLasts =
+        m_min ? m_lasts[m_min - 1] : m_lasts[0];
 
     if (!copies) {
         goto inf_check;
@@ -317,7 +324,7 @@ void ComponentRepeat::wireRepeats(GlushkovBuildState &bs,
     DEBUG_PRINTF("wiring up %d optional repeats\n", copies - m_min);
     for (u32 rep = MAX(m_min, 1); rep < copies; rep++) {
         vector<PositionInfo> lasts = m_lasts[rep - 1];
-        if (m_min && rep != m_min) {
+        if (rep != m_min) {
             lasts.insert(lasts.end(), optLasts.begin(), optLasts.end());
             sort(lasts.begin(), lasts.end());
             lasts.erase(unique(lasts.begin(), lasts.end()), lasts.end());
@@ -333,42 +340,6 @@ inf_check:
     }
 }
 
-void ComponentRepeat::precalc_firsts() {
-    DEBUG_PRINTF("building firsts for {%u,%u} repeat with %s sub\n", m_min,
-                 m_max, sub_comp->empty() ? "emptiable" : "non-emptiable");
-
-    /* For normal repeat, our optional repeats each have an epsilon at the end
-     * of their firsts lists.
-     */
-    for (u32 i = m_min; i < m_firsts.size();i++) {
-        m_firsts[i].insert(m_firsts[i].end(), GlushkovBuildState::POS_EPSILON);
-    }
-
-    firsts_cache.clear();
-    if (!m_max) {
-        return;
-    }
-
-    assert(!m_firsts.empty()); // notePositions should already have run
-    const vector<PositionInfo> &f = m_firsts.front();
-
-    // If we're running without edge priorities, then we want to generate the
-    // repeat in such a way that the firsts do all the work. This will minimise
-    // the number of exceptional states in a LimEx NFA implementation.
-
-    if (!m_min || sub_comp->empty()) {
-        // Emptiable: all our repeats contribute to firsts.
-        // Each repeat's firsts is spliced in at the location of the epsilon
-        // (if any) in the previous repeat's firsts.
-        for (const auto &e : m_firsts) {
-            replaceEpsilons(firsts_cache, e);
-        }
-    } else {
-        // Not emptiable: firsts come from our first repeat only.
-        firsts_cache.insert(firsts_cache.end(), f.begin(), f.end());
-    }
-}
-
 static
 bool hasPositionFlags(const Component &c) {
     for (const auto &e : c.first()) {
diff --git a/src/parser/ComponentRepeat.h b/src/parser/ComponentRepeat.h
index e8305ffd..8905bfcf 100644
--- a/src/parser/ComponentRepeat.h
+++ b/src/parser/ComponentRepeat.h
@@ -42,30 +42,33 @@
 
 namespace ue2 {
 
-/** \brief Encapsulates a repeat of a subexpression ('*', '+', '?', '{M,N}',
+/**
+ * \brief Encapsulates a repeat of a subexpression ('*', '+', '?', '{M,N}',
  * etc).
  *
- * Ascii Art Time:
+ * ASCII Art Time:
  *
  * Our standard representation of standard repeats. Other constructions (fan-in
  * vs fan-out) would also be possible and equivalent for our purposes.
  *
  * {n,m}
  *
- * S->M->M->M->O->O->O->T
- *          |     ^  ^  ^
- *          |     |  |  |
- *          \-----------/
+ *     S->M->M->M->O->O->O->T
+ *              |     ^  ^  ^
+ *              |     |  |  |
+ *              \-----------/
  *
  * {0,m}
  *
- * S->O->O->O->T
- * |     ^  ^  ^
- * |     |  |  |
- * \-----------/
+ *     /-----------\
+ *     |           |
+ *     |           V
+ *     S->O->O->O->T
+ *        |  ^  ^  ^
+ *        |  |  |  |
+ *        \--------/
  *
  */
-
 class ComponentRepeat : public Component {
     friend class ConstructLiteralVisitor;
     friend class DumpVisitor;
@@ -117,11 +120,8 @@ public:
     enum RepeatType type;
 
 protected:
-    /** Called by \ref buildFollowSet to connect up the various repeats. */
-    void precalc_firsts();
     void postSubNotePositionHook();
-    void wireRepeats(GlushkovBuildState &bs,
-                     const std::vector<PositionInfo> &lastPos);
+    void wireRepeats(GlushkovBuildState &bs);
 
     std::unique_ptr<Component> sub_comp;
     u32 m_min;
@@ -132,8 +132,6 @@ protected:
     Position posFirst;
     Position posLast;
 
-    std::vector<PositionInfo> firsts_cache;
-
     ComponentRepeat(const ComponentRepeat &other);
 };
 
diff --git a/src/parser/check_refs.cpp b/src/parser/check_refs.cpp
index ad81ae76..fae68f74 100644
--- a/src/parser/check_refs.cpp
+++ b/src/parser/check_refs.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -73,6 +73,8 @@ public:
         throw ParseError(str.str());
     }
 
+    using DefaultConstComponentVisitor::pre;
+
     void pre(const ComponentBackReference &c) override {
         if (c.ref_id) {
             if (c.ref_id >= num_ids) {
diff --git a/src/parser/prefilter.cpp b/src/parser/prefilter.cpp
index f5a0c66c..ea58a134 100644
--- a/src/parser/prefilter.cpp
+++ b/src/parser/prefilter.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -80,6 +80,9 @@ public:
         return numPositions <= MAX_REFERENT_POSITIONS;
     }
 
+    using DefaultConstComponentVisitor::pre;
+    using DefaultConstComponentVisitor::post;
+
     void pre(const AsciiComponentClass &) override {
         numPositions++;
     }
@@ -164,6 +167,8 @@ public:
     explicit FindSequenceVisitor(unsigned ref_id) : id(ref_id) {}
     explicit FindSequenceVisitor(const std::string &s) : name(s) {}
 
+    using DefaultConstComponentVisitor::pre;
+
     void pre(const ComponentSequence &c) override {
         if (!name.empty()) {
             if (c.getCaptureName() == name) {
@@ -203,6 +208,8 @@ public:
     PrefilterVisitor(Component *c, const ParseMode &m) : root(c), mode(m) {}
     ~PrefilterVisitor() override;
 
+    using DefaultComponentVisitor::visit;
+
     /** \brief Calls the visitor (recursively) on a new replacement component
      * we've just created. Takes care of freeing it if the sequence is itself
      * replaced. */
diff --git a/src/parser/ucp_table.cpp b/src/parser/ucp_table.cpp
index 7b53d1d6..fc1330fe 100644
--- a/src/parser/ucp_table.cpp
+++ b/src/parser/ucp_table.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -83,14 +83,13 @@ void make_caseless(CodePointSet *cps) {
 
     CodePointSet base = *cps;
 
-    const unicase *uc_begin = ucp_caseless_def;
-    const unicase *const uc_end = ucp_caseless_def
-                                  + ARRAY_LENGTH(ucp_caseless_def);
-    DEBUG_PRINTF("uc len %zd\n", uc_end - uc_begin);
+    auto uc_begin = begin(ucp_caseless_def);
+    auto uc_end = end(ucp_caseless_def);
+    DEBUG_PRINTF("uc len %zd\n", distance(uc_begin, uc_end));
 
-    for (auto it = base.begin(), ite = base.end(); it != ite; ++it) {
-        unichar b = lower(*it);
-        unichar e = upper(*it) + 1;
+    for (const auto &elem : base) {
+        unichar b = lower(elem);
+        unichar e = upper(elem) + 1;
 
         for (; b < e; b++) {
             DEBUG_PRINTF("decasing %x\n", b);
@@ -101,7 +100,7 @@ void make_caseless(CodePointSet *cps) {
                 DEBUG_PRINTF("EOL\n");
                 return;
             }
-            while (uc_begin->base == b) {
+            while (uc_begin != uc_end && uc_begin->base == b) {
                 DEBUG_PRINTF("at {%x,%x}\n", uc_begin->base, uc_begin->caseless);
                 cps->set(uc_begin->caseless);
                 ++uc_begin;
@@ -117,13 +116,12 @@ void make_caseless(CodePointSet *cps) {
 bool flip_case(unichar *c) {
     assert(c);
 
-    const unicase *const uc_begin = ucp_caseless_def;
-    const unicase *const uc_end =
-        ucp_caseless_def + ARRAY_LENGTH(ucp_caseless_def);
-
     const unicase test = { *c, 0 };
-    const unicase *f = lower_bound(uc_begin, uc_end, test);
-    if (f->base == *c) {
+
+    const auto uc_begin = begin(ucp_caseless_def);
+    const auto uc_end = end(ucp_caseless_def);
+    const auto f = lower_bound(uc_begin, uc_end, test);
+    if (f != uc_end && f->base == *c) {
         DEBUG_PRINTF("flipped c=%x to %x\n", *c, f->caseless);
         *c = f->caseless;
         return true;
diff --git a/src/parser/unsupported.cpp b/src/parser/unsupported.cpp
index c97a5750..c4b18b6a 100644
--- a/src/parser/unsupported.cpp
+++ b/src/parser/unsupported.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -45,6 +45,7 @@ namespace ue2 {
 class UnsupportedVisitor : public DefaultConstComponentVisitor {
 public:
     ~UnsupportedVisitor() override;
+    using DefaultConstComponentVisitor::pre;
     void pre(const ComponentAssertion &) override {
         throw ParseError("Zero-width assertions are not supported.");
     }
diff --git a/src/report.h b/src/report.h
new file mode 100644
index 00000000..d037d11b
--- /dev/null
+++ b/src/report.h
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** \file
+ * \brief Runtime functions to do with reports, inlined into callers.
+ */
+
+#ifndef REPORT_H
+#define REPORT_H
+
+#include "hs_internal.h"
+#include "hs_runtime.h"
+#include "scratch.h"
+#include "ue2common.h"
+#include "nfa/callback.h"
+#include "nfa/nfa_internal.h"
+#include "rose/runtime.h"
+#include "som/som_runtime.h"
+#include "util/exhaust.h"
+#include "util/fatbit.h"
+
+enum DedupeResult {
+    DEDUPE_CONTINUE, //!< Continue with match, not a dupe.
+    DEDUPE_SKIP, //!< Don't report this match, dupe or delayed due to SOM.
+    DEDUPE_HALT //!< User instructed us to stop matching.
+};
+
+static really_inline
+enum DedupeResult dedupeCatchup(const struct RoseEngine *rose,
+                                struct hs_scratch *scratch, u64a offset,
+                                u64a from_offset, u64a to_offset, u32 dkey,
+                                s32 offset_adjust, char is_external_report,
+                                char quash_som, const char do_som) {
+    DEBUG_PRINTF("offset=%llu, match=[%llu,%llu], dkey=%u, do_som=%d\n", offset,
+                 from_offset, to_offset, dkey, do_som);
+
+    // We should not have been called if there's no dedupe work to do.
+    assert(do_som || dkey != MO_INVALID_IDX);
+
+    struct match_deduper *deduper = &scratch->deduper;
+    if (offset != deduper->current_report_offset) {
+        assert(deduper->current_report_offset == ~0ULL ||
+               deduper->current_report_offset < offset);
+        if (offset == deduper->current_report_offset + 1) {
+            fatbit_clear(deduper->log[offset % 2]);
+        } else {
+            fatbit_clear(deduper->log[0]);
+            fatbit_clear(deduper->log[1]);
+        }
+
+        if (do_som && flushStoredSomMatches(scratch, offset)) {
+            return DEDUPE_HALT;
+        }
+        deduper->current_report_offset = offset;
+    }
+
+    if (dkey != MO_INVALID_IDX) {
+        const u32 dkeyCount = rose->dkeyCount;
+        if (is_external_report || quash_som) {
+            DEBUG_PRINTF("checking dkey %u at offset %llu\n", dkey, to_offset);
+            assert(offset_adjust == 0 || offset_adjust == -1);
+            if (fatbit_set(deduper->log[to_offset % 2], dkeyCount, dkey)) {
+                /* we have already raised this report at this offset, squash
+                 * dupe match. */
+                DEBUG_PRINTF("dedupe\n");
+                return DEDUPE_SKIP;
+            }
+        } else if (do_som) {
+            /* SOM external event */
+            DEBUG_PRINTF("checking dkey %u at offset %llu\n", dkey, to_offset);
+            assert(offset_adjust == 0 || offset_adjust == -1);
+            u64a *starts = deduper->som_start_log[to_offset % 2];
+            if (fatbit_set(deduper->som_log[to_offset % 2], dkeyCount, dkey)) {
+                starts[dkey] = MIN(starts[dkey], from_offset);
+            } else {
+                starts[dkey] = from_offset;
+            }
+            DEBUG_PRINTF("starts[%u]=%llu\n", dkey, starts[dkey]);
+
+            if (offset_adjust) {
+                deduper->som_log_dirty |= 1;
+            } else {
+                deduper->som_log_dirty |= 2;
+            }
+
+            return DEDUPE_SKIP;
+        }
+    }
+
+    return DEDUPE_CONTINUE;
+}
+
+/**
+ * \brief Deliver the given report to the user callback.
+ *
+ * Assumes all preconditions (bounds, exhaustion etc) have been checked and
+ * that dedupe catchup has been done.
+ */
+static really_inline
+int roseDeliverReport(u64a offset, ReportID onmatch, s32 offset_adjust,
+                      struct hs_scratch *scratch, u32 ekey) {
+    assert(scratch);
+    assert(scratch->magic == SCRATCH_MAGIC);
+
+    struct core_info *ci = &scratch->core_info;
+
+    u32 flags = 0;
+#ifndef RELEASE_BUILD
+    if (offset_adjust) {
+        // alert testing tools that we've got adjusted matches
+        flags |= HS_MATCH_FLAG_ADJUSTED;
+    }
+#endif
+
+    assert(!can_stop_matching(scratch));
+    assert(ekey == INVALID_EKEY ||
+           !isExhausted(ci->rose, ci->exhaustionVector, ekey));
+
+    u64a from_offset = 0;
+    u64a to_offset = offset + offset_adjust;
+
+    DEBUG_PRINTF(">> reporting match @[%llu,%llu] for sig %u ctxt %p <<\n",
+                 from_offset, to_offset, onmatch, ci->userContext);
+
+    int halt = ci->userCallback(onmatch, from_offset, to_offset, flags,
+                                ci->userContext);
+    if (halt) {
+        DEBUG_PRINTF("callback requested to terminate matches\n");
+        ci->status |= STATUS_TERMINATED;
+        return MO_HALT_MATCHING;
+    }
+
+    if (ekey != INVALID_EKEY) {
+        markAsMatched(ci->rose, ci->exhaustionVector, ekey);
+        return MO_CONTINUE_MATCHING;
+    } else {
+        return ROSE_CONTINUE_MATCHING_NO_EXHAUST;
+    }
+}
+
+/**
+ * \brief Deliver the given SOM report to the user callback.
+ *
+ * Assumes all preconditions (bounds, exhaustion etc) have been checked and
+ * that dedupe catchup has been done.
+ */
+static really_inline
+int roseDeliverSomReport(u64a from_offset, u64a to_offset, ReportID onmatch,
+                         s32 offset_adjust, struct hs_scratch *scratch,
+                         u32 ekey) {
+    assert(scratch);
+    assert(scratch->magic == SCRATCH_MAGIC);
+
+    struct core_info *ci = &scratch->core_info;
+
+    u32 flags = 0;
+#ifndef RELEASE_BUILD
+    if (offset_adjust) {
+        // alert testing tools that we've got adjusted matches
+        flags |= HS_MATCH_FLAG_ADJUSTED;
+    }
+#endif
+
+    assert(!can_stop_matching(scratch));
+    assert(ekey == INVALID_EKEY ||
+           !isExhausted(ci->rose, ci->exhaustionVector, ekey));
+
+    to_offset += offset_adjust;
+    assert(from_offset == HS_OFFSET_PAST_HORIZON || from_offset <= to_offset);
+
+    DEBUG_PRINTF(">> reporting match @[%llu,%llu] for sig %u ctxt %p <<\n",
+                 from_offset, to_offset, onmatch, ci->userContext);
+
+    int halt = ci->userCallback(onmatch, from_offset, to_offset, flags,
+                                ci->userContext);
+
+    if (halt) {
+        DEBUG_PRINTF("callback requested to terminate matches\n");
+        ci->status |= STATUS_TERMINATED;
+        return MO_HALT_MATCHING;
+    }
+
+    if (ekey != INVALID_EKEY) {
+        markAsMatched(ci->rose, ci->exhaustionVector, ekey);
+        return MO_CONTINUE_MATCHING;
+    } else {
+        return ROSE_CONTINUE_MATCHING_NO_EXHAUST;
+    }
+}
+
+#endif // REPORT_H
diff --git a/src/rose/block.c b/src/rose/block.c
index 6f28832e..5fc5c8a1 100644
--- a/src/rose/block.c
+++ b/src/rose/block.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -34,7 +34,6 @@
 #include "nfa/nfa_rev_api.h"
 #include "nfa/mcclellan.h"
 #include "util/fatbit.h"
-#include "rose_sidecar_runtime.h"
 #include "rose.h"
 #include "rose_common.h"
 
@@ -62,11 +61,11 @@ void runAnchoredTableBlock(const struct RoseEngine *t, const void *atable,
             if (nfa->type == MCCLELLAN_NFA_8) {
                 nfaExecMcClellan8_B(nfa, curr->anchoredMinDistance,
                                     local_buffer, local_alen,
-                                    roseAnchoredCallback, &scratch->tctxt);
+                                    roseAnchoredCallback, scratch);
             } else {
                 nfaExecMcClellan16_B(nfa, curr->anchoredMinDistance,
                                      local_buffer, local_alen,
-                                     roseAnchoredCallback, &scratch->tctxt);
+                                     roseAnchoredCallback, scratch);
             }
         }
 
@@ -79,26 +78,12 @@ void runAnchoredTableBlock(const struct RoseEngine *t, const void *atable,
 }
 
 static really_inline
-void init_sidecar(const struct RoseEngine *t, struct hs_scratch *scratch) {
-    if (!t->smatcherOffset) {
-        return;
-    }
-
-    DEBUG_PRINTF("welcome to the sidecar\n");
-    assert(t->initSideEnableOffset);
-    // We have to enable some sidecar literals
-    const char *template = (const char *)t + t->initSideEnableOffset;
-
-    memcpy(&scratch->side_enabled, template, t->stateOffsets.sidecar_size);
-}
-
-static really_inline
-void init_state_for_block(const struct RoseEngine *t, u8 *state) {
+void init_state_for_block(const struct RoseEngine *t, char *state) {
     assert(t);
     assert(state);
 
-    DEBUG_PRINTF("init for Rose %p with %u roles (%u with state indices)\n",
-                 t, t->roleCount, t->rolesWithStateCount);
+    DEBUG_PRINTF("init for Rose %p with %u state indices\n", t,
+                 t->rolesWithStateCount);
 
     // Rose is guaranteed 8-aligned state
     assert(ISALIGNED_N(state, 8));
@@ -108,7 +93,7 @@ void init_state_for_block(const struct RoseEngine *t, u8 *state) {
 
 static really_inline
 void init_outfixes_for_block(const struct RoseEngine *t,
-                             struct hs_scratch *scratch, u8 *state,
+                             struct hs_scratch *scratch, char *state,
                              char is_small_block) {
     /* active leaf array has been cleared by the init scatter */
 
@@ -120,7 +105,6 @@ void init_outfixes_for_block(const struct RoseEngine *t,
         size_t len = nfaRevAccelCheck(nfa, scratch->core_info.buf,
                                       scratch->core_info.len);
         if (len) {
-            struct RoseContext *tctxt = &scratch->tctxt;
             u8 *activeArray = getActiveLeafArray(t, state);
             const u32 activeArraySize = t->activeArrayCount;
             const u32 qCount = t->queueCount;
@@ -129,7 +113,7 @@ void init_outfixes_for_block(const struct RoseEngine *t,
             fatbit_set(scratch->aqa, qCount, 0);
 
             struct mq *q = scratch->queues;
-            initQueue(q, 0, t, tctxt);
+            initQueue(q, 0, t, scratch);
             q->length = len; /* adjust for rev_accel */
             nfaQueueInitState(nfa, q);
             pushQueueAt(q, 0, MQE_START, 0);
@@ -149,46 +133,31 @@ void init_outfixes_for_block(const struct RoseEngine *t,
 
 static really_inline
 void init_for_block(const struct RoseEngine *t, struct hs_scratch *scratch,
-                    RoseCallback callback, RoseCallbackSom som_callback,
-                    void *ctxt, u8 *state, char is_small_block) {
+                    char *state, char is_small_block) {
     init_state_for_block(t, state);
 
     struct RoseContext *tctxt = &scratch->tctxt;
 
-    tctxt->t = t;
-    tctxt->depth = 1;
     tctxt->groups = t->initialGroups;
     tctxt->lit_offset_adjust = 1; // index after last byte
     tctxt->delayLastEndOffset = 0;
     tctxt->lastEndOffset = 0;
     tctxt->filledDelayedSlots = 0;
-    tctxt->state = state;
-    tctxt->cb = callback;
-    tctxt->cb_som = som_callback;
-    tctxt->userCtx = ctxt;
     tctxt->lastMatchOffset = 0;
     tctxt->minMatchOffset = 0;
     tctxt->minNonMpvMatchOffset = 0;
     tctxt->next_mpv_offset = 0;
-    tctxt->curr_anchored_loc = MMB_INVALID;
-    tctxt->curr_row_offset = 0;
-    tctxt->side_curr = 0;
 
-    scratch->am_log_sum = 0; /* clear the anchored logs */
     scratch->al_log_sum = 0;
 
     fatbit_clear(scratch->aqa);
 
-    init_sidecar(t, scratch); /* Init the sidecar enabled state */
-
     scratch->catchup_pq.qm_size = 0;
 
     init_outfixes_for_block(t, scratch, state, is_small_block);
 }
 
-void roseBlockExec_i(const struct RoseEngine *t, struct hs_scratch *scratch,
-                     RoseCallback callback, RoseCallbackSom som_callback,
-                     void *ctx) {
+void roseBlockExec_i(const struct RoseEngine *t, struct hs_scratch *scratch) {
     assert(t);
     assert(scratch);
     assert(scratch->core_info.buf);
@@ -204,10 +173,9 @@ void roseBlockExec_i(const struct RoseEngine *t, struct hs_scratch *scratch,
     const char is_small_block =
         (length < ROSE_SMALL_BLOCK_LEN && t->sbmatcherOffset);
 
-    u8 *state = (u8 *)scratch->core_info.state;
+    char *state = scratch->core_info.state;
 
-    init_for_block(t, scratch, callback, som_callback, ctx, state,
-                   is_small_block);
+    init_for_block(t, scratch, state, is_small_block);
 
     struct RoseContext *tctxt = &scratch->tctxt;
 
@@ -220,7 +188,7 @@ void roseBlockExec_i(const struct RoseEngine *t, struct hs_scratch *scratch,
         DEBUG_PRINTF("BEGIN SMALL BLOCK (over %zu/%zu)\n", sblen, length);
         DEBUG_PRINTF("-- %016llx\n", tctxt->groups);
         hwlmExec(sbtable, scratch->core_info.buf, sblen, 0, roseCallback,
-                 tctxt, tctxt->groups);
+                 scratch, tctxt->groups);
         goto exit;
     }
 
@@ -243,7 +211,6 @@ void roseBlockExec_i(const struct RoseEngine *t, struct hs_scratch *scratch,
             goto exit;
         }
 
-        resetAnchoredLog(t, scratch);
     skip_atable:;
     }
 
@@ -251,7 +218,7 @@ void roseBlockExec_i(const struct RoseEngine *t, struct hs_scratch *scratch,
     if (ftable) {
         DEBUG_PRINTF("ftable fd=%u fmd %u\n", t->floatingDistance,
             t->floatingMinDistance);
-        if (t->noFloatingRoots && tctxt->depth == 1) {
+        if (t->noFloatingRoots && !roseHasInFlightMatches(t, state, scratch)) {
             DEBUG_PRINTF("skip FLOATING: no inflight matches\n");
             goto exit;
         }
@@ -277,17 +244,15 @@ void roseBlockExec_i(const struct RoseEngine *t, struct hs_scratch *scratch,
         DEBUG_PRINTF("BEGIN FLOATING (over %zu/%zu)\n", flen, length);
         DEBUG_PRINTF("-- %016llx\n", tctxt->groups);
         hwlmExec(ftable, buffer, flen, t->floatingMinDistance,
-                 roseCallback, tctxt, tctxt->groups);
+                 roseCallback, scratch, tctxt->groups);
     }
 
 exit:;
-    u8 dummy_delay_mask = 0;
-    if (cleanUpDelayed(length, 0, tctxt, &dummy_delay_mask)
-        == HWLM_TERMINATE_MATCHING) {
+    if (cleanUpDelayed(t, scratch, length, 0) == HWLM_TERMINATE_MATCHING) {
         return;
     }
 
     assert(!can_stop_matching(scratch));
 
-    roseCatchUpTo(t, state, length, scratch, 0);
+    roseCatchUpTo(t, scratch, length);
 }
diff --git a/src/rose/catchup.c b/src/rose/catchup.c
index 77b12b49..dba9629e 100644
--- a/src/rose/catchup.c
+++ b/src/rose/catchup.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,8 +26,14 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+/**
+ * \file
+ * \brief Rose runtime: code for catching up output-exposed engines.
+ */
+
 #include "catchup.h"
 #include "match.h"
+#include "program_runtime.h"
 #include "rose.h"
 #include "nfa/nfa_rev_api.h"
 #include "nfa/mpv.h"
@@ -41,108 +47,23 @@ typedef struct queue_match PQ_T;
 #include "util/pqueue.h"
 
 static really_inline
-int handleReportInternally(struct hs_scratch *scratch, ReportID id,
-                           u64a offset) {
-    const struct internal_report *ri = getInternalReport(scratch->tctxt.t, id);
-    if (ri->type == EXTERNAL_CALLBACK) {
-        return 0;
-    }
-    if (isInternalSomReport(ri)) {
-        handleSomInternal(scratch, ri, offset);
-        return 1;
-    }
-    if (ri->type == INTERNAL_ROSE_CHAIN) {
-        roseHandleChainMatch(scratch->tctxt.t, id, offset, &scratch->tctxt, 0,
-                             1);
-        return 1;
-    }
+int roseNfaRunProgram(const struct RoseEngine *rose, struct hs_scratch *scratch,
+                      u64a som, u64a offset, ReportID id, const char from_mpv) {
+    const u32 program = id;
+    const size_t match_len = 0; // Unused in this path.
+    const char in_anchored = 0;
+    const char in_catchup = 1;
+    roseRunProgram(rose, scratch, program, som, offset, match_len, in_anchored,
+                   in_catchup, from_mpv, 0);
 
-    return 0;
+    return can_stop_matching(scratch) ? MO_HALT_MATCHING : MO_CONTINUE_MATCHING;
 }
 
 static really_inline
-int handleReportInternallyNoChain(struct hs_scratch *scratch, ReportID id,
-                                  u64a offset) {
-    const struct internal_report *ri = getInternalReport(scratch->tctxt.t, id);
-    if (ri->type == EXTERNAL_CALLBACK) {
-        return 0;
-    }
-    if (isInternalSomReport(ri)) {
-        handleSomInternal(scratch, ri, offset);
-        return 1;
-    }
-    if (ri->type == INTERNAL_ROSE_CHAIN) {
-        assert(0); /* chained engines cannot trigger other engines */
-        return 1;
-    }
-
-    return 0;
-}
-
-static really_inline
-void currentAnchoredMatch(const struct RoseEngine *t,
-                          struct RoseContext *tctxt, ReportID *reportId,
-                          u64a *end) {
-    if (tctxt->curr_anchored_loc == MMB_INVALID) {
-        *end = ANCHORED_MATCH_SENTINEL;
-        *reportId = ANCHORED_MATCH_SENTINEL;
-        DEBUG_PRINTF("curr %u [idx = %u] @%llu\n", *reportId,
-                     tctxt->curr_row_offset, *end);
-        return;
-    }
-
-    *end = tctxt->curr_anchored_loc + t->maxSafeAnchoredDROffset + 1;
-    *reportId = getAnchoredMap(t)[tctxt->curr_row_offset];
-
-    DEBUG_PRINTF("curr %u [idx = %u] @%llu\n", *reportId,
-                 tctxt->curr_row_offset, *end);
-}
-
-static rose_inline
-void nextAnchoredMatch(const struct RoseEngine *t, struct RoseContext *tctxt,
-                       ReportID *reportId, u64a *end) {
-    assert(tctxt->curr_anchored_loc != MMB_INVALID);
-
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-    u8 **anchoredRows = getAnchoredLog(scratch);
-
-    u32 region_width = t->anchoredMatches;
-    u8 *curr_row = anchoredRows[tctxt->curr_anchored_loc];
-
-    tctxt->curr_row_offset = mmbit_iterate(curr_row, region_width,
-                                           tctxt->curr_row_offset);
-    DEBUG_PRINTF("next %u [idx = %u] @%llu\n", *reportId,
-                 tctxt->curr_row_offset, *end);
-    if (tctxt->curr_row_offset != MMB_INVALID) {
-        *end = tctxt->curr_anchored_loc + t->maxSafeAnchoredDROffset + 1;
-        *reportId = getAnchoredMap(t)[tctxt->curr_row_offset];
-        return;
-    }
-
-    tctxt->curr_anchored_loc = bf64_iterate(scratch->am_log_sum,
-                                            tctxt->curr_anchored_loc);
-
-    if (tctxt->curr_anchored_loc == MMB_INVALID) {
-        *end = ANCHORED_MATCH_SENTINEL;
-        *reportId = ANCHORED_MATCH_SENTINEL;
-        return;
-    }
-
-    assert(tctxt->curr_anchored_loc < scratch->anchored_region_len);
-    curr_row = anchoredRows[tctxt->curr_anchored_loc];
-
-    tctxt->curr_row_offset = mmbit_iterate(curr_row, region_width,
-                                           MMB_INVALID);
-    assert(tctxt->curr_row_offset != MMB_INVALID);
-
-    *end = tctxt->curr_anchored_loc + t->maxSafeAnchoredDROffset + 1;
-    *reportId = getAnchoredMap(t)[tctxt->curr_row_offset];
-}
-
-static really_inline
-void deactivateQueue(u8 *aa, u32 qi, struct hs_scratch *scratch) {
-    u32 aaCount = scratch->tctxt.t->activeArrayCount;
-    u32 qCount = scratch->tctxt.t->queueCount;
+void deactivateQueue(const struct RoseEngine *t, u8 *aa, u32 qi,
+                     struct hs_scratch *scratch) {
+    u32 aaCount = t->activeArrayCount;
+    u32 qCount = t->queueCount;
 
     /* this is sailing close to the wind with regards to invalidating an
      * iteration. We are saved by the fact that unsetting does not clear the
@@ -158,7 +79,7 @@ void ensureQueueActive(const struct RoseEngine *t, u32 qi, u32 qCount,
                        struct mq *q, struct hs_scratch *scratch) {
     if (!fatbit_set(scratch->aqa, qCount, qi)) {
         DEBUG_PRINTF("initing %u\n", qi);
-        initQueue(q, qi, t, &scratch->tctxt);
+        initQueue(q, qi, t, scratch);
         loadStreamState(q->nfa, q, 0);
         pushQueueAt(q, 0, MQE_START, 0);
     }
@@ -209,7 +130,8 @@ s64a pq_top_loc(struct catchup_pq *pq) {
 
 /* requires that we are the top item on the pq */
 static really_inline
-hwlmcb_rv_t runExistingNfaToNextMatch(u32 qi, struct mq *q, s64a loc,
+hwlmcb_rv_t runExistingNfaToNextMatch(const struct RoseEngine *t, u32 qi,
+                                      struct mq *q, s64a loc,
                                       struct hs_scratch *scratch, u8 *aa,
                                       char report_curr) {
     assert(pq_top(scratch->catchup_pq.qm)->queue == qi);
@@ -240,7 +162,7 @@ hwlmcb_rv_t runExistingNfaToNextMatch(u32 qi, struct mq *q, s64a loc,
             return HWLM_TERMINATE_MATCHING;
         }
 
-        deactivateQueue(aa, qi, scratch);
+        deactivateQueue(t, aa, qi, scratch);
     } else if (q->cur == q->end) {
         DEBUG_PRINTF("queue %u finished, nfa lives\n", qi);
         q->cur = q->end = 0;
@@ -265,7 +187,8 @@ hwlmcb_rv_t runExistingNfaToNextMatch(u32 qi, struct mq *q, s64a loc,
 }
 
 static really_inline
-hwlmcb_rv_t runNewNfaToNextMatch(u32 qi, struct mq *q, s64a loc,
+hwlmcb_rv_t runNewNfaToNextMatch(const struct RoseEngine *t, u32 qi,
+                                 struct mq *q, s64a loc,
                                  struct hs_scratch *scratch, u8 *aa,
                                  s64a report_ok_loc) {
     assert(!q->report_current);
@@ -298,7 +221,7 @@ restart:
             return HWLM_TERMINATE_MATCHING;
         }
 
-        deactivateQueue(aa, qi, scratch);
+        deactivateQueue(t, aa, qi, scratch);
     } else if (q->cur == q->end) {
         DEBUG_PRINTF("queue %u finished, nfa lives\n", qi);
         q->cur = q->end = 0;
@@ -321,56 +244,23 @@ restart:
 }
 
 /* for use by mpv (chained) only */
-static UNUSED
+static
 int roseNfaFinalBlastAdaptor(u64a offset, ReportID id, void *context) {
-    struct RoseContext *tctxt = context;
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    DEBUG_PRINTF("called\n");
+    struct hs_scratch *scratch = context;
+    const struct RoseEngine *t = scratch->core_info.rose;
 
     DEBUG_PRINTF("masky got himself a blasted match @%llu id %u !woot!\n",
                  offset, id);
-    updateLastMatchOffset(tctxt, offset);
 
-    if (handleReportInternallyNoChain(scratch, id, offset)) {
-        return MO_CONTINUE_MATCHING;
-    }
-
-    int cb_rv = tctxt->cb(offset, id, tctxt->userCtx);
+    int cb_rv = roseNfaRunProgram(t, scratch, 0, offset, id, 1);
     if (cb_rv == MO_HALT_MATCHING) {
         return MO_HALT_MATCHING;
     } else if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
         return MO_CONTINUE_MATCHING;
     } else {
         assert(cb_rv == MO_CONTINUE_MATCHING);
-       return !roseSuffixIsExhausted(tctxt->t, 0,
-                                     scratch->core_info.exhaustionVector);
-    }
-}
-
-/* for use by mpv (chained) only */
-static UNUSED
-int roseNfaFinalBlastAdaptorNoInternal(u64a offset, ReportID id,
-                                       void *context) {
-    struct RoseContext *tctxt = context;
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    DEBUG_PRINTF("called\n");
-    /* chained nfas are run under the control of the anchored catchup */
-
-    DEBUG_PRINTF("masky got himself a blasted match @%llu id %u !woot!\n",
-                 offset, id);
-    updateLastMatchOffset(tctxt, offset);
-
-    int cb_rv = tctxt->cb(offset, id, tctxt->userCtx);
-    if (cb_rv == MO_HALT_MATCHING) {
-        return MO_HALT_MATCHING;
-    } else if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
-        return MO_CONTINUE_MATCHING;
-    } else {
-        assert(cb_rv == MO_CONTINUE_MATCHING);
-       return !roseSuffixIsExhausted(tctxt->t, 0,
-                                     scratch->core_info.exhaustionVector);
+        return !roseSuffixIsExhausted(t, 0,
+                                      scratch->core_info.exhaustionVector);
     }
 }
 
@@ -393,7 +283,7 @@ hwlmcb_rv_t add_to_queue(const struct RoseEngine *t, struct mq *queues,
 
     if (roseSuffixInfoIsExhausted(t, info,
                                   scratch->core_info.exhaustionVector)) {
-        deactivateQueue(aa, qi, scratch);
+        deactivateQueue(t, aa, qi, scratch);
         return HWLM_CONTINUE_MATCHING;
     }
 
@@ -406,7 +296,7 @@ hwlmcb_rv_t add_to_queue(const struct RoseEngine *t, struct mq *queues,
 
     ensureEnd(q, qi, loc);
 
-    return runNewNfaToNextMatch(qi, q, loc, scratch, aa, report_ok_loc);
+    return runNewNfaToNextMatch(t, qi, q, loc, scratch, aa, report_ok_loc);
 }
 
 static really_inline
@@ -427,8 +317,9 @@ s64a findSecondPlace(struct catchup_pq *pq, s64a loc_limit) {
     }
 }
 
-hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, u8 *state, s64a loc,
+hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, s64a loc,
                              struct hs_scratch *scratch) {
+    char *state = scratch->core_info.state;
     struct mq *queues = scratch->queues;
     u8 *aa = getActiveLeafArray(t, state);
     UNUSED u32 aaCount = t->activeArrayCount;
@@ -451,7 +342,7 @@ hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, u8 *state, s64a loc,
 
     if (roseSuffixInfoIsExhausted(t, info,
                                   scratch->core_info.exhaustionVector)) {
-        deactivateQueue(aa, qi, scratch);
+        deactivateQueue(t, aa, qi, scratch);
         goto done;
     }
 
@@ -466,11 +357,7 @@ hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, u8 *state, s64a loc,
 
     assert(!q->report_current);
 
-    if (info->only_external) {
-        q->cb = roseNfaFinalBlastAdaptorNoInternal;
-    } else {
-        q->cb = roseNfaFinalBlastAdaptor;
-    }
+    q->cb = roseNfaFinalBlastAdaptor;
     q->som_cb = NULL;
 
     DEBUG_PRINTF("queue %u blasting, %u/%u [%lld/%lld]\n",
@@ -485,7 +372,7 @@ hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, u8 *state, s64a loc,
     if (!next_pos_match_loc) { /* 0 means dead */
         DEBUG_PRINTF("mpv is pining for the fjords\n");
         if (can_stop_matching(scratch)) {
-            deactivateQueue(aa, qi, scratch);
+            deactivateQueue(t, aa, qi, scratch);
             return HWLM_TERMINATE_MATCHING;
         }
 
@@ -514,188 +401,104 @@ done:
                                       : HWLM_CONTINUE_MATCHING;
 }
 
-static UNUSED
+static really_inline
+char in_mpv(const struct RoseEngine *rose, const struct hs_scratch *scratch) {
+    const struct RoseContext *tctxt = &scratch->tctxt;
+    assert(tctxt->curr_qi < rose->queueCount);
+    if (tctxt->curr_qi < rose->outfixBeginQueue) {
+        assert(getNfaByQueue(rose, tctxt->curr_qi)->type == MPV_NFA_0);
+        return 1;
+    }
+    return 0;
+}
+
+static
 int roseNfaBlastAdaptor(u64a offset, ReportID id, void *context) {
-    struct RoseContext *tctxt = context;
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    const struct internal_report *ri = getInternalReport(scratch->tctxt.t, id);
-
-    DEBUG_PRINTF("called\n");
-    if (ri->type != INTERNAL_ROSE_CHAIN) {
-        /* INTERNAL_ROSE_CHAIN are not visible externally */
-        if (roseCatchUpMPV(tctxt->t, tctxt->state,
-                           offset - scratch->core_info.buf_offset, scratch)
-            == HWLM_TERMINATE_MATCHING) {
-            DEBUG_PRINTF("done\n");
-            return MO_HALT_MATCHING;
-        }
-    }
+    struct hs_scratch *scratch = context;
+    struct RoseContext *tctxt = &scratch->tctxt;
+    const struct RoseEngine *t = scratch->core_info.rose;
 
     DEBUG_PRINTF("masky got himself a blasted match @%llu id %u !woot!\n",
                  offset, id);
 
-    if (handleReportInternally(scratch, id, offset)) {
-        return MO_CONTINUE_MATCHING;
-    }
-
-    updateLastMatchOffset(tctxt, offset);
-
-    int cb_rv = tctxt->cb(offset, id, tctxt->userCtx);
+    const char from_mpv = in_mpv(t, scratch);
+    int cb_rv = roseNfaRunProgram(t, scratch, 0, offset, id, from_mpv);
     if (cb_rv == MO_HALT_MATCHING) {
         return MO_HALT_MATCHING;
     } else if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
         return MO_CONTINUE_MATCHING;
     } else {
         assert(cb_rv == MO_CONTINUE_MATCHING);
-       return !roseSuffixIsExhausted(tctxt->t, tctxt->curr_qi,
-                                     scratch->core_info.exhaustionVector);
+        return !roseSuffixIsExhausted(t, tctxt->curr_qi,
+                                      scratch->core_info.exhaustionVector);
     }
 }
 
-static UNUSED
+static
 int roseNfaBlastAdaptorNoInternal(u64a offset, ReportID id, void *context) {
-    struct RoseContext *tctxt = context;
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    DEBUG_PRINTF("called\n");
-    if (roseCatchUpMPV(tctxt->t, tctxt->state,
-                       offset - scratch->core_info.buf_offset, scratch)
-        == HWLM_TERMINATE_MATCHING) {
-        DEBUG_PRINTF("done\n");
-        return MO_HALT_MATCHING;
-    }
+    struct hs_scratch *scratch = context;
+    struct RoseContext *tctxt = &scratch->tctxt;
+    const struct RoseEngine *t = scratch->core_info.rose;
 
     DEBUG_PRINTF("masky got himself a blasted match @%llu id %u !woot!\n",
                  offset, id);
-    updateLastMatchOffset(tctxt, offset);
 
-    int cb_rv = tctxt->cb(offset, id, tctxt->userCtx);
+    assert(!in_mpv(t, scratch));
+
+    int cb_rv = roseNfaRunProgram(t, scratch, 0, offset, id, 0);
     if (cb_rv == MO_HALT_MATCHING) {
         return MO_HALT_MATCHING;
     } else if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
         return MO_CONTINUE_MATCHING;
     } else {
         assert(cb_rv == MO_CONTINUE_MATCHING);
-       return !roseSuffixIsExhausted(tctxt->t, tctxt->curr_qi,
-                                     scratch->core_info.exhaustionVector);
+        return !roseSuffixIsExhausted(t, tctxt->curr_qi,
+                                      scratch->core_info.exhaustionVector);
     }
 }
 
-static UNUSED
-int roseNfaBlastAdaptorNoChain(u64a offset, ReportID id, void *context) {
-    struct RoseContext *tctxt = context;
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    DEBUG_PRINTF("masky got himself a blasted match @%llu id %u !woot!\n",
-                 offset, id);
-
-    updateLastMatchOffset(tctxt, offset);
-
-    if (handleReportInternallyNoChain(scratch, id, offset)) {
-        return MO_CONTINUE_MATCHING;
-    }
-
-    int cb_rv = tctxt->cb(offset, id, tctxt->userCtx);
-    if (cb_rv == MO_HALT_MATCHING) {
-        return MO_HALT_MATCHING;
-    } else if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
-        return MO_CONTINUE_MATCHING;
-    } else {
-        assert(cb_rv == MO_CONTINUE_MATCHING);
-       return !roseSuffixIsExhausted(tctxt->t, tctxt->curr_qi,
-                                     scratch->core_info.exhaustionVector);
-    }
-}
-
-static UNUSED
-int roseNfaBlastAdaptorNoInternalNoChain(u64a offset, ReportID id,
-                                         void *context) {
-    struct RoseContext *tctxt = context;
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    /* chained nfas are run under the control of the anchored catchup */
-
-    DEBUG_PRINTF("masky got himself a blasted match @%llu id %u !woot!\n",
-                 offset, id);
-    updateLastMatchOffset(tctxt, offset);
-
-    int cb_rv = tctxt->cb(offset, id, tctxt->userCtx);
-    if (cb_rv == MO_HALT_MATCHING) {
-        return MO_HALT_MATCHING;
-    } else if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
-        return MO_CONTINUE_MATCHING;
-    } else {
-        assert(cb_rv == MO_CONTINUE_MATCHING);
-       return !roseSuffixIsExhausted(tctxt->t, tctxt->curr_qi,
-                                     scratch->core_info.exhaustionVector);
-    }
-}
-
-static UNUSED
+static
 int roseNfaBlastSomAdaptor(u64a from_offset, u64a offset, ReportID id,
                            void *context) {
-    struct RoseContext *tctxt = context;
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    DEBUG_PRINTF("called\n");
-    if (roseCatchUpMPV(tctxt->t, tctxt->state,
-                       offset - scratch->core_info.buf_offset, scratch)
-        == HWLM_TERMINATE_MATCHING) {
-        DEBUG_PRINTF("roseCatchUpNfas done\n");
-        return MO_HALT_MATCHING;
-    }
+    struct hs_scratch *scratch = context;
+    struct RoseContext *tctxt = &scratch->tctxt;
+    const struct RoseEngine *t = scratch->core_info.rose;
 
     DEBUG_PRINTF("masky got himself a blasted match @%llu id %u !woot!\n",
                  offset, id);
-    updateLastMatchOffset(tctxt, offset);
+
+    assert(!in_mpv(t, scratch));
 
     /* must be a external report as haig cannot directly participate in chain */
-    int cb_rv = tctxt->cb_som(from_offset, offset, id, tctxt->userCtx);
+    int cb_rv = roseNfaRunProgram(scratch->core_info.rose, scratch, from_offset,
+                                  offset, id, 0);
     if (cb_rv == MO_HALT_MATCHING) {
         return MO_HALT_MATCHING;
     } else if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
         return MO_CONTINUE_MATCHING;
     } else {
         assert(cb_rv == MO_CONTINUE_MATCHING);
-       return !roseSuffixIsExhausted(tctxt->t, tctxt->curr_qi,
-                                     scratch->core_info.exhaustionVector);
+        return !roseSuffixIsExhausted(t, tctxt->curr_qi,
+                                      scratch->core_info.exhaustionVector);
     }
 }
 
 int roseNfaAdaptor(u64a offset, ReportID id, void *context) {
-    struct RoseContext *tctxt = context;
+    struct hs_scratch *scratch = context;
     DEBUG_PRINTF("masky got himself a match @%llu id %u !woot!\n", offset, id);
 
-    updateLastMatchOffset(tctxt, offset);
-
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-    if (handleReportInternally(scratch, id, offset)) {
-        return MO_CONTINUE_MATCHING;
-    }
-
-    int cb_rv = tctxt->cb(offset, id, tctxt->userCtx);
-    return cb_rv;
-}
-
-int roseNfaAdaptorNoInternal(u64a offset, ReportID id, void *context) {
-    struct RoseContext *tctxt = context;
-    DEBUG_PRINTF("masky got himself a match @%llu id %u !woot!\n", offset, id);
-    updateLastMatchOffset(tctxt, offset);
-
-    int cb_rv = tctxt->cb(offset, id, tctxt->userCtx);
-    return cb_rv;
+    return roseNfaRunProgram(scratch->core_info.rose, scratch, 0, offset, id,
+                             0);
 }
 
 int roseNfaSomAdaptor(u64a from_offset, u64a offset, ReportID id,
                       void *context) {
-    struct RoseContext *tctxt = context;
+    struct hs_scratch *scratch = context;
     DEBUG_PRINTF("masky got himself a match @%llu id %u !woot!\n", offset, id);
-    updateLastMatchOffset(tctxt, offset);
 
     /* must be a external report as haig cannot directly participate in chain */
-    int cb_rv = tctxt->cb_som(from_offset, offset, id, tctxt->userCtx);
-    return cb_rv;
+    return roseNfaRunProgram(scratch->core_info.rose, scratch, from_offset,
+                             offset, id, 0);
 }
 
 static really_inline
@@ -705,29 +508,17 @@ char blast_queue(const struct RoseEngine *t, struct hs_scratch *scratch,
     const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
 
     tctxt->curr_qi = qi;
-    if (has_chained_nfas(t)) {
-        if (info->only_external) {
-            q->cb = roseNfaBlastAdaptorNoInternal;
-        } else {
-            q->cb = roseNfaBlastAdaptor;
-        }
+    if (info->only_external) {
+        q->cb = roseNfaBlastAdaptorNoInternal;
     } else {
-        if (info->only_external) {
-            q->cb = roseNfaBlastAdaptorNoInternalNoChain;
-        } else {
-            q->cb = roseNfaBlastAdaptorNoChain;
-        }
+        q->cb = roseNfaBlastAdaptor;
     }
     q->report_current = report_current;
     q->som_cb = roseNfaBlastSomAdaptor;
     DEBUG_PRINTF("queue %u blasting, %u/%u [%lld/%lld]\n", qi, q->cur, q->end,
                  q_cur_loc(q), to_loc);
     char alive = nfaQueueExec(q->nfa, q, to_loc);
-    if (info->only_external) {
-        q->cb = roseNfaAdaptorNoInternal;
-    } else {
-        q->cb = roseNfaAdaptor;
-    }
+    q->cb = roseNfaAdaptor;
     q->som_cb = roseNfaSomAdaptor;
     assert(!q->report_current);
 
@@ -745,7 +536,7 @@ hwlmcb_rv_t buildSufPQ_final(const struct RoseEngine *t, s64a report_ok_loc,
 
     if (roseSuffixInfoIsExhausted(t, info,
                                   scratch->core_info.exhaustionVector)) {
-        deactivateQueue(aa, a_qi, scratch);
+        deactivateQueue(t, aa, a_qi, scratch);
         return HWLM_CONTINUE_MATCHING;
     }
 
@@ -760,7 +551,7 @@ hwlmcb_rv_t buildSufPQ_final(const struct RoseEngine *t, s64a report_ok_loc,
 
     char alive = blast_queue(t, scratch, q, a_qi, second_place_loc, 0);
 
-    /* We have three posible outcomes:
+    /* We have three possible outcomes:
      * (1) the nfa died
      * (2) we completed the queue (implies that second_place_loc == final_loc)
      * (3) the queue ran to second_place_loc and stopped. In this case we need
@@ -773,7 +564,7 @@ hwlmcb_rv_t buildSufPQ_final(const struct RoseEngine *t, s64a report_ok_loc,
             return HWLM_TERMINATE_MATCHING;
         }
 
-        deactivateQueue(aa, a_qi, scratch);
+        deactivateQueue(t, aa, a_qi, scratch);
     } else if (q->cur == q->end) {
         DEBUG_PRINTF("queue %u finished, nfa lives [%lld]\n", a_qi, final_loc);
 
@@ -789,8 +580,8 @@ hwlmcb_rv_t buildSufPQ_final(const struct RoseEngine *t, s64a report_ok_loc,
         assert(second_place_loc < final_loc);
         assert(q_cur_loc(q) >= second_place_loc);
 
-        if (runNewNfaToNextMatch(a_qi, q, final_loc, scratch, aa,  report_ok_loc)
-            == HWLM_TERMINATE_MATCHING) {
+        if (runNewNfaToNextMatch(t, a_qi, q, final_loc, scratch, aa,
+                                 report_ok_loc) == HWLM_TERMINATE_MATCHING) {
             DEBUG_PRINTF("roseCatchUpNfas done\n");
             return HWLM_TERMINATE_MATCHING;
         }
@@ -799,7 +590,7 @@ hwlmcb_rv_t buildSufPQ_final(const struct RoseEngine *t, s64a report_ok_loc,
     return HWLM_CONTINUE_MATCHING;
 }
 
-void streamInitSufPQ(const struct RoseEngine *t, u8 *state,
+void streamInitSufPQ(const struct RoseEngine *t, char *state,
                      struct hs_scratch *scratch) {
     assert(scratch->catchup_pq.qm_size == 0);
     assert(t->outfixBeginQueue != t->outfixEndQueue);
@@ -830,7 +621,7 @@ void streamInitSufPQ(const struct RoseEngine *t, u8 *state,
 
             pq_insert_with(&scratch->catchup_pq, scratch, qi, qcl);
         } else if (!alive) {
-            deactivateQueue(aa, qi, scratch);
+            deactivateQueue(t, aa, qi, scratch);
         } else {
             assert(q->cur == q->end);
             /* TODO: can this be simplified? the nfa will never produce any
@@ -844,7 +635,7 @@ void streamInitSufPQ(const struct RoseEngine *t, u8 *state,
     }
 }
 
-void blockInitSufPQ(const struct RoseEngine *t, u8 *state,
+void blockInitSufPQ(const struct RoseEngine *t, char *state,
                     struct hs_scratch *scratch, char is_small_block) {
     DEBUG_PRINTF("initSufPQ: outfixes [%u,%u)\n", t->outfixBeginQueue,
                  t->outfixEndQueue);
@@ -877,7 +668,7 @@ void blockInitSufPQ(const struct RoseEngine *t, u8 *state,
         mmbit_set(aa, aaCount, qi);
         fatbit_set(aqa, qCount, qi);
         struct mq *q = queues + qi;
-        initQueue(q, qi, t, &scratch->tctxt);
+        initQueue(q, qi, t, scratch);
         q->length = len; /* adjust for rev_accel */
         nfaQueueInitState(nfa, q);
         pushQueueAt(q, 0, MQE_START, 0);
@@ -894,7 +685,7 @@ void blockInitSufPQ(const struct RoseEngine *t, u8 *state,
 
             pq_insert_with(&scratch->catchup_pq, scratch, qi, qcl);
         } else if (!alive) {
-            deactivateQueue(aa, qi, scratch);
+            deactivateQueue(t, aa, qi, scratch);
         } else {
             assert(q->cur == q->end);
             /* TODO: can this be simplified? the nfa will never produce any
@@ -910,7 +701,7 @@ void blockInitSufPQ(const struct RoseEngine *t, u8 *state,
  * safe_loc is ???
  */
 static rose_inline
-hwlmcb_rv_t buildSufPQ(const struct RoseEngine *t, u8 *state, s64a safe_loc,
+hwlmcb_rv_t buildSufPQ(const struct RoseEngine *t, char *state, s64a safe_loc,
                        s64a final_loc, struct hs_scratch *scratch) {
     assert(scratch->catchup_pq.qm_size <= t->outfixEndQueue);
 
@@ -949,8 +740,9 @@ hwlmcb_rv_t buildSufPQ(const struct RoseEngine *t, u8 *state, s64a safe_loc,
     s64a report_ok_loc = tctxt->minNonMpvMatchOffset + 1
         - scratch->core_info.buf_offset;
 
-    hwlmcb_rv_t rv = roseCatchUpMPV(tctxt->t, state, report_ok_loc, scratch);
+    hwlmcb_rv_t rv = roseCatchUpMPV(t, report_ok_loc, scratch);
     if (rv != HWLM_CONTINUE_MATCHING) {
+        DEBUG_PRINTF("terminating...\n");
         return rv;
     }
 
@@ -986,16 +778,19 @@ hwlmcb_rv_t buildSufPQ(const struct RoseEngine *t, u8 *state, s64a safe_loc,
 }
 
 static never_inline
-hwlmcb_rv_t roseCatchUpNfas(const struct RoseEngine *t, u8 *state, s64a loc,
+hwlmcb_rv_t roseCatchUpNfas(const struct RoseEngine *t, s64a loc,
                             s64a final_loc, struct hs_scratch *scratch) {
-    struct RoseContext *tctxt = &scratch->tctxt;
     assert(t->activeArrayCount);
 
-    assert(scratch->core_info.buf_offset + loc >= tctxt->minNonMpvMatchOffset);
-    DEBUG_PRINTF("roseCatchUpNfas %lld/%lld\n", loc, final_loc);
+    DEBUG_PRINTF("roseCatchUpNfas offset=%llu + %lld/%lld\n",
+                 scratch->core_info.buf_offset, loc, final_loc);
     DEBUG_PRINTF("min non mpv match offset %llu\n",
                  scratch->tctxt.minNonMpvMatchOffset);
 
+    struct RoseContext *tctxt = &scratch->tctxt;
+    assert(scratch->core_info.buf_offset + loc >= tctxt->minNonMpvMatchOffset);
+
+    char *state = scratch->core_info.state;
     struct mq *queues = scratch->queues;
     u8 *aa = getActiveLeafArray(t, state);
 
@@ -1016,7 +811,7 @@ hwlmcb_rv_t roseCatchUpNfas(const struct RoseEngine *t, u8 *state, s64a loc,
         }
 
         /* catch up char matches to this point */
-        if (roseCatchUpMPV(t, state, match_loc, scratch)
+        if (roseCatchUpMPV(t, match_loc, scratch)
             == HWLM_TERMINATE_MATCHING) {
             DEBUG_PRINTF("roseCatchUpNfas done\n");
             return HWLM_TERMINATE_MATCHING;
@@ -1043,7 +838,7 @@ hwlmcb_rv_t roseCatchUpNfas(const struct RoseEngine *t, u8 *state, s64a loc,
         DEBUG_PRINTF("second place %lld loc %lld\n", second_place_loc, loc);
 
         if (second_place_loc == q_cur_loc(q)) {
-            if (runExistingNfaToNextMatch(qi, q, q_final_loc, scratch, aa, 1)
+            if (runExistingNfaToNextMatch(t, qi, q, q_final_loc, scratch, aa, 1)
                 == HWLM_TERMINATE_MATCHING) {
                 return HWLM_TERMINATE_MATCHING;
             }
@@ -1058,7 +853,7 @@ hwlmcb_rv_t roseCatchUpNfas(const struct RoseEngine *t, u8 *state, s64a loc,
                 return HWLM_TERMINATE_MATCHING;
             }
 
-            deactivateQueue(aa, qi, scratch);
+            deactivateQueue(t, aa, qi, scratch);
             pq_pop_nice(&scratch->catchup_pq);
         } else if (q->cur == q->end) {
             DEBUG_PRINTF("queue %u finished, nfa lives [%lld]\n", qi, loc);
@@ -1072,7 +867,7 @@ hwlmcb_rv_t roseCatchUpNfas(const struct RoseEngine *t, u8 *state, s64a loc,
         } else {
             DEBUG_PRINTF("queue %u not finished, %u/%u [%lld/%lld]\n",
                           qi, q->cur, q->end, q->items[q->cur].location, loc);
-            runExistingNfaToNextMatch(qi, q, q_final_loc, scratch, aa, 0);
+            runExistingNfaToNextMatch(t, qi, q, q_final_loc, scratch, aa, 0);
         }
     }
 exit:;
@@ -1081,119 +876,7 @@ exit:;
     return HWLM_CONTINUE_MATCHING;
 }
 
-static really_inline
-hwlmcb_rv_t roseCatchUpNfasAndMpv(const struct RoseEngine *t, u8 *state,
-                                  s64a loc, s64a final_loc,
-                                  struct hs_scratch *scratch) {
-    hwlmcb_rv_t rv = roseCatchUpNfas(t, state, loc, final_loc, scratch);
-
-    if (rv != HWLM_CONTINUE_MATCHING) {
-        return rv;
-    }
-
-    return roseCatchUpMPV(t, state, loc, scratch);
-}
-
-
-static really_inline
-hwlmcb_rv_t roseCatchUpAll_i(s64a loc, struct hs_scratch *scratch,
-                             char do_full_mpv) {
-    assert(scratch->tctxt.t->activeArrayCount); /* otherwise use
-                                                 * roseCatchUpAnchoredOnly */
-    struct RoseContext *tctxt = &scratch->tctxt;
-    u64a current_offset = scratch->core_info.buf_offset + loc;
-
-    u64a anchored_end;
-    ReportID anchored_report;
-    currentAnchoredMatch(tctxt->t, tctxt, &anchored_report, &anchored_end);
-
-    DEBUG_PRINTF("am current_offset %llu\n", current_offset);
-    DEBUG_PRINTF("min match offset %llu\n", scratch->tctxt.minMatchOffset);
-    DEBUG_PRINTF("min non mpv match offset %llu\n",
-                 scratch->tctxt.minNonMpvMatchOffset);
-
-    assert(current_offset > tctxt->minMatchOffset);
-    assert(anchored_end != ANCHORED_MATCH_SENTINEL);
-
-    hwlmcb_rv_t rv = buildSufPQ(tctxt->t, tctxt->state,
-                                anchored_end - scratch->core_info.buf_offset,
-                                loc, scratch);
-    if (rv != HWLM_CONTINUE_MATCHING) {
-        return rv;
-    }
-
-    /* buildSufPQ may have caught only part of the pq upto anchored_end */
-    rv = roseCatchUpNfas(tctxt->t, tctxt->state,
-                        anchored_end - scratch->core_info.buf_offset, loc,
-                        scratch);
-
-    if (rv != HWLM_CONTINUE_MATCHING) {
-        return rv;
-    }
-
-    while (anchored_report != MO_INVALID_IDX
-           && anchored_end <= current_offset) {
-        if (anchored_end != tctxt->minMatchOffset) {
-            rv = roseCatchUpNfasAndMpv(tctxt->t, tctxt->state,
-                                  anchored_end - scratch->core_info.buf_offset,
-                                  loc, scratch);
-            if (rv != HWLM_CONTINUE_MATCHING) {
-                DEBUG_PRINTF("halting\n");
-                return rv;
-            }
-        }
-
-        assert(anchored_end == tctxt->minMatchOffset);
-        updateLastMatchOffset(tctxt, anchored_end);
-
-        if (handleReportInternally(scratch, anchored_report, anchored_end)) {
-            goto next;
-        }
-
-        if (tctxt->cb(anchored_end, anchored_report, tctxt->userCtx)
-            == MO_HALT_MATCHING) {
-            DEBUG_PRINTF("termination requested\n");
-            return HWLM_TERMINATE_MATCHING;
-        }
-    next:
-         nextAnchoredMatch(tctxt->t, tctxt, &anchored_report, &anchored_end);
-         DEBUG_PRINTF("catch up %u %llu\n", anchored_report, anchored_end);
-    }
-
-    if (current_offset == tctxt->minMatchOffset) {
-        DEBUG_PRINTF("caught up\n");
-        assert(scratch->catchup_pq.qm_size <= tctxt->t->outfixEndQueue);
-        return HWLM_CONTINUE_MATCHING;
-    }
-
-    rv = roseCatchUpNfas(tctxt->t, tctxt->state, loc, loc, scratch);
-
-    if (rv != HWLM_CONTINUE_MATCHING) {
-        return rv;
-    }
-
-    assert(scratch->catchup_pq.qm_size <= tctxt->t->outfixEndQueue
-           || rv == HWLM_TERMINATE_MATCHING);
-
-    if (do_full_mpv) {
-        /* finish off any outstanding chained matches */
-        rv = roseCatchUpMPV(tctxt->t, tctxt->state, loc, scratch);
-    }
-
-    DEBUG_PRINTF("catchup all done %llu\n", current_offset);
-
-    return rv;
-}
-
 hwlmcb_rv_t roseCatchUpAll(s64a loc, struct hs_scratch *scratch) {
-    return roseCatchUpAll_i(loc, scratch, 1);
-}
-
-hwlmcb_rv_t roseCatchUpAnchoredAndSuf(s64a loc, struct hs_scratch *scratch) {
-    return roseCatchUpAll_i(loc, scratch, 0);
-}
-
-hwlmcb_rv_t roseCatchUpSufAndChains(s64a loc, struct hs_scratch *scratch) {
     /* just need suf/outfixes and mpv */
     DEBUG_PRINTF("loc %lld mnmmo %llu mmo %llu\n", loc,
                  scratch->tctxt.minNonMpvMatchOffset,
@@ -1201,24 +884,23 @@ hwlmcb_rv_t roseCatchUpSufAndChains(s64a loc, struct hs_scratch *scratch) {
     assert(scratch->core_info.buf_offset + loc
            > scratch->tctxt.minNonMpvMatchOffset);
 
-    hwlmcb_rv_t rv = buildSufPQ(scratch->tctxt.t, scratch->tctxt.state, loc,
-                                loc, scratch);
+    const struct RoseEngine *t = scratch->core_info.rose;
+    char *state = scratch->core_info.state;
+
+    hwlmcb_rv_t rv = buildSufPQ(t, state, loc, loc, scratch);
     if (rv != HWLM_CONTINUE_MATCHING) {
         return rv;
     }
 
-    rv = roseCatchUpNfas(scratch->tctxt.t, scratch->tctxt.state, loc, loc,
-                         scratch);
-
+    rv = roseCatchUpNfas(t, loc, loc, scratch);
     if (rv != HWLM_CONTINUE_MATCHING) {
         return rv;
     }
 
-    rv = roseCatchUpMPV(scratch->tctxt.t, scratch->tctxt.state, loc, scratch);
-
+    rv = roseCatchUpMPV(t, loc, scratch);
     assert(rv != HWLM_CONTINUE_MATCHING
-           || scratch->catchup_pq.qm_size <= scratch->tctxt.t->outfixEndQueue);
-
+           || scratch->catchup_pq.qm_size <= t->outfixEndQueue);
+    assert(!can_stop_matching(scratch) || rv == HWLM_TERMINATE_MATCHING);
     return rv;
 }
 
@@ -1228,54 +910,17 @@ hwlmcb_rv_t roseCatchUpSuf(s64a loc, struct hs_scratch *scratch) {
     assert(scratch->core_info.buf_offset + loc
            > scratch->tctxt.minNonMpvMatchOffset);
 
-    hwlmcb_rv_t rv = buildSufPQ(scratch->tctxt.t, scratch->tctxt.state, loc,
-                                loc, scratch);
+    const struct RoseEngine *t = scratch->core_info.rose;
+    char *state = scratch->core_info.state;
+
+    hwlmcb_rv_t rv = buildSufPQ(t, state, loc, loc, scratch);
     if (rv != HWLM_CONTINUE_MATCHING) {
         return rv;
     }
 
-    rv = roseCatchUpNfas(scratch->tctxt.t, scratch->tctxt.state, loc, loc,
-                         scratch);
-    assert(rv != HWLM_CONTINUE_MATCHING
-           || scratch->catchup_pq.qm_size <= scratch->tctxt.t->outfixEndQueue);
+    rv = roseCatchUpNfas(t, loc, loc, scratch);
+    assert(rv != HWLM_CONTINUE_MATCHING ||
+           scratch->catchup_pq.qm_size <= t->outfixEndQueue);
 
     return rv;
 }
-
-hwlmcb_rv_t roseCatchUpAnchoredOnly(s64a loc, struct hs_scratch *scratch) {
-    struct RoseContext *tctxt = &scratch->tctxt;
-
-    assert(!tctxt->t->activeArrayCount); /* otherwise use roseCatchUpAll */
-
-    u64a current_offset = scratch->core_info.buf_offset + loc;
-    u64a anchored_end;
-    ReportID anchored_report;
-    currentAnchoredMatch(tctxt->t, tctxt, &anchored_report, &anchored_end);
-
-    DEBUG_PRINTF("am current_offset %llu\n", current_offset);
-
-    assert(current_offset > tctxt->minMatchOffset);
-
-    while (anchored_report != MO_INVALID_IDX
-           && anchored_end <= current_offset) {
-        updateLastMatchOffset(tctxt, anchored_end);
-
-        /* as we require that there are no leaf nfas - there must be no nfa */
-        if (handleReportInternallyNoChain(scratch, anchored_report,
-                                          anchored_end)) {
-            goto next;
-        }
-
-        if (tctxt->cb(anchored_end, anchored_report, tctxt->userCtx)
-                        == MO_HALT_MATCHING) {
-            DEBUG_PRINTF("termination requested\n");
-            return HWLM_TERMINATE_MATCHING;
-        }
-    next:
-        nextAnchoredMatch(tctxt->t, tctxt, &anchored_report, &anchored_end);
-        DEBUG_PRINTF("catch up %u %llu\n", anchored_report, anchored_end);
-    }
-
-    updateMinMatchOffset(tctxt, current_offset);
-    return HWLM_CONTINUE_MATCHING;
-}
diff --git a/src/rose/catchup.h b/src/rose/catchup.h
index b54a49b0..24b843f5 100644
--- a/src/rose/catchup.h
+++ b/src/rose/catchup.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,6 +26,25 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+/**
+ * \file
+ * \brief Rose runtime: code for catching up output-exposed engines.
+ *
+ * Rose has several components which run behind the main (floating table) clock
+ * and need to be caught up before we report matches.
+ *
+ * Currently we have to deal with:
+ * 1. Suffix/Outfix NFAs
+ * 2. A single MPV NFA (chained), which may also be triggered by (1).
+ *
+ * The approach is to:
+ * - (A) build a priority queue of the suffix/outfixes based on their first
+ *       match location;
+ * - (B) process the matches from the priority queue in order;
+ * - (C) As we report matches from (B) we interleave matches from the MPV if it
+ *       exists.
+ */
+
 #ifndef ROSE_CATCHUP_H
 #define ROSE_CATCHUP_H
 
@@ -35,113 +54,72 @@
 #include "rose_common.h"
 #include "rose_internal.h"
 #include "ue2common.h"
-#include "nfa/nfa_internal.h"
-#include "util/bitutils.h"
 #include "util/multibit.h"
 
-/*
- * Rose has several components which run behind the main (floating table) clock
- * and need to be caught up before we report matches.
- *
- * Currently we have to deal with:
- * 1) Stored matches from the anchored matcher
- * 2) Suffix/Outfix nfas
- * 3) a single MPV nfa (chained) (which may also be triggered by (1) and (2)).
- *
- * The approach is to:
- * A) build a priority queue of the suffix/outfixes based on their first match
- *    location
- * B) process the matches from the anchored matches in order
- * C) As we report a match from (B) we interleave matches from the suffixes
- * D) As we report matches from (B) and (C) we interleave matches from the
- *    mpv if it exists.
- */
-
-/* Callbacks, defined in catchup.c */
-
-hwlmcb_rv_t roseCatchUpSufAndChains(s64a loc, struct hs_scratch *scratch);
-
 hwlmcb_rv_t roseCatchUpAll(s64a loc, struct hs_scratch *scratch);
 
-hwlmcb_rv_t roseCatchUpAnchoredOnly(s64a loc, struct hs_scratch *scratch);
-
-
-/* will only catch mpv upto last reported external match */
+/* will only catch mpv up to last reported external match */
 hwlmcb_rv_t roseCatchUpSuf(s64a loc, struct hs_scratch *scratch);
 
-/* will only catch mpv upto last reported external match */
-hwlmcb_rv_t roseCatchUpAnchoredAndSuf(s64a loc, struct hs_scratch *scratch);
-
-
-hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, u8 *state, s64a loc,
+hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, s64a loc,
                              struct hs_scratch *scratch);
 
-void blockInitSufPQ(const struct RoseEngine *t, u8 *state,
+void blockInitSufPQ(const struct RoseEngine *t, char *state,
                     struct hs_scratch *scratch, char is_small_block);
-void streamInitSufPQ(const struct RoseEngine *t, u8 *state,
+void streamInitSufPQ(const struct RoseEngine *t, char *state,
                      struct hs_scratch *scratch);
 
 static really_inline
-hwlmcb_rv_t roseCatchUpMPV(const struct RoseEngine *t, u8 *state,
-                           s64a loc, struct hs_scratch *scratch) {
-    u64a cur_offset = loc + scratch->core_info.buf_offset;
-    assert(cur_offset >= scratch->tctxt.minMatchOffset);
-
-    if (0) {
-    quick_exit:
-        updateMinMatchOffsetFromMpv(&scratch->tctxt, cur_offset);
-        return HWLM_CONTINUE_MATCHING;
-    }
-
+int canSkipCatchUpMPV(const struct RoseEngine *t, struct hs_scratch *scratch,
+                      u64a cur_offset) {
     if (!has_chained_nfas(t)) {
-        goto quick_exit;
+        return 1;
     }
 
     /* note: we may have to run at less than tctxt.minMatchOffset as we may
      * have a full queue of postponed events that we need to flush */
     if (cur_offset < scratch->tctxt.next_mpv_offset) {
-        DEBUG_PRINTF("skipping cur_offset %lld min %lld, mpv %lld\n",
+        DEBUG_PRINTF("skipping cur_offset %llu min %llu, mpv %llu\n",
                       cur_offset, scratch->tctxt.minMatchOffset,
                       scratch->tctxt.next_mpv_offset);
-        goto quick_exit;
+        return 1;
     }
 
     assert(t->activeArrayCount);
 
-    DEBUG_PRINTF("cur offset offset: %lld\n", cur_offset);
+    DEBUG_PRINTF("cur offset offset: %llu\n", cur_offset);
     DEBUG_PRINTF("min match offset %llu\n", scratch->tctxt.minMatchOffset);
 
-    DEBUG_PRINTF("roseCatchUpMPV to %lld\n", loc);
-
     assert(t->outfixBeginQueue == 1); /* if it exists mpv is queue 0 */
 
-    u8 *aa = getActiveLeafArray(t, state);
-    u32 aaCount = t->activeArrayCount;
+    const u8 *aa = getActiveLeafArray(t, scratch->core_info.state);
+    return !mmbit_isset(aa, t->activeArrayCount, 0);
+}
 
-    if (!mmbit_isset(aa, aaCount, 0)){
-        goto quick_exit;
+/** \brief Catches up the MPV. */
+static really_inline
+hwlmcb_rv_t roseCatchUpMPV(const struct RoseEngine *t, s64a loc,
+                           struct hs_scratch *scratch) {
+    u64a cur_offset = loc + scratch->core_info.buf_offset;
+    assert(cur_offset >= scratch->tctxt.minMatchOffset);
+    assert(!can_stop_matching(scratch));
+
+    if (canSkipCatchUpMPV(t, scratch, cur_offset)) {
+        updateMinMatchOffsetFromMpv(&scratch->tctxt, cur_offset);
+        return HWLM_CONTINUE_MATCHING;
     }
 
     /* Note: chained tails MUST not participate in the priority queue as
      * they may have events pushed on during this process which may be before
      * the catch up point */
 
-    return roseCatchUpMPV_i(t, state, loc, scratch);
+    return roseCatchUpMPV_i(t, loc, scratch);
 }
 
-static really_inline
-u64a currentAnchoredEnd(const struct RoseEngine *t, struct RoseContext *tctxt) {
-    if (tctxt->curr_anchored_loc == MMB_INVALID) {
-        return ANCHORED_MATCH_SENTINEL;
-    } else {
-        return tctxt->curr_anchored_loc + t->maxSafeAnchoredDROffset + 1;
-    }
-}
-
-/* catches up nfas, anchored matches and the mpv */
+/** \brief Catches up NFAs and the MPV. */
 static rose_inline
-hwlmcb_rv_t roseCatchUpTo(const struct RoseEngine *t, u8 *state, u64a end,
-                          struct hs_scratch *scratch, char in_anchored) {
+hwlmcb_rv_t roseCatchUpTo(const struct RoseEngine *t,
+                          struct hs_scratch *scratch, u64a end) {
     /* no need to catch up if we are at the same offset as last time */
     if (end <= scratch->tctxt.minMatchOffset) {
         /* we must already be up to date */
@@ -149,49 +127,42 @@ hwlmcb_rv_t roseCatchUpTo(const struct RoseEngine *t, u8 *state, u64a end,
         return HWLM_CONTINUE_MATCHING;
     }
 
+    char *state = scratch->core_info.state;
     s64a loc = end - scratch->core_info.buf_offset;
 
     if (end <= scratch->tctxt.minNonMpvMatchOffset) {
         /* only need to catch up the mpv */
-        return roseCatchUpMPV(t, state, loc, scratch);
+        return roseCatchUpMPV(t, loc, scratch);
     }
 
-    assert(t == scratch->tctxt.t);
     assert(scratch->tctxt.minMatchOffset >= scratch->core_info.buf_offset);
-    u64a curr_anchored_end = currentAnchoredEnd(t, &scratch->tctxt);
     hwlmcb_rv_t rv;
-    if (in_anchored
-        || curr_anchored_end == ANCHORED_MATCH_SENTINEL
-        || curr_anchored_end > end) {
-        if (!t->activeArrayCount
-            || !mmbit_any(getActiveLeafArray(t, state), t->activeArrayCount)) {
-            updateMinMatchOffset(&scratch->tctxt, end);
-            rv = HWLM_CONTINUE_MATCHING;
-        } else {
-            rv = roseCatchUpSufAndChains(loc, scratch);
-        }
+    if (!t->activeArrayCount
+        || !mmbit_any(getActiveLeafArray(t, state), t->activeArrayCount)) {
+        updateMinMatchOffset(&scratch->tctxt, end);
+        rv = HWLM_CONTINUE_MATCHING;
     } else {
-        if (!t->activeArrayCount) {
-            rv = roseCatchUpAnchoredOnly(loc, scratch);
-        } else {
-            rv = roseCatchUpAll(loc, scratch);
-        }
+        rv = roseCatchUpAll(loc, scratch);
     }
 
     assert(rv != HWLM_CONTINUE_MATCHING
            || scratch->tctxt.minMatchOffset == end);
     assert(rv != HWLM_CONTINUE_MATCHING
            || scratch->tctxt.minNonMpvMatchOffset == end);
+    assert(!can_stop_matching(scratch) || rv == HWLM_TERMINATE_MATCHING);
     return rv;
 }
 
-/* Catches up anything which may add triggers on the mpv: anchored matches
- * and suf/outfixes. The MPV will be run only to intersperse matches in
- * the output match stream if external matches are raised. */
+/**
+ * \brief Catches up anything which may add triggers on the MPV (suffixes and
+ * outfixes).
+ *
+ * The MPV will be run only to intersperse matches in the output match stream
+ * if external matches are raised.
+ */
 static rose_inline
-hwlmcb_rv_t roseCatchUpMpvFeeders(const struct RoseEngine *t, u8 *state,
-                                  u64a end, struct hs_scratch *scratch,
-                                  char in_anchored) {
+hwlmcb_rv_t roseCatchUpMpvFeeders(const struct RoseEngine *t,
+                                  struct hs_scratch *scratch, u64a end) {
     /* no need to catch up if we are at the same offset as last time */
     if (end <= scratch->tctxt.minNonMpvMatchOffset) {
         /* we must already be up to date */
@@ -201,29 +172,23 @@ hwlmcb_rv_t roseCatchUpMpvFeeders(const struct RoseEngine *t, u8 *state,
 
     s64a loc = end - scratch->core_info.buf_offset;
 
-    assert(t == scratch->tctxt.t);
     assert(t->activeArrayCount); /* mpv is in active array */
     assert(scratch->tctxt.minMatchOffset >= scratch->core_info.buf_offset);
-    u64a curr_anchored_end = currentAnchoredEnd(t, &scratch->tctxt);
-    if (in_anchored
-        || curr_anchored_end == ANCHORED_MATCH_SENTINEL
-        || curr_anchored_end > end) {
-        if (!t->mpvTriggeredByLeaf) {
-            /* no need to check as they never put triggers onto the mpv */
-            return HWLM_CONTINUE_MATCHING;
-        }
 
-        /* sadly, this branch rarely gets taken as the mpv itself is usually
-         * alive. */
-        if (!mmbit_any(getActiveLeafArray(t, state), t->activeArrayCount)) {
-            scratch->tctxt.minNonMpvMatchOffset = end;
-            return HWLM_CONTINUE_MATCHING;
-        }
-
-        return roseCatchUpSuf(loc, scratch);
-    } else {
-        return roseCatchUpAnchoredAndSuf(loc, scratch);
+    if (!t->mpvTriggeredByLeaf) {
+        /* no need to check as they never put triggers onto the mpv */
+        return HWLM_CONTINUE_MATCHING;
     }
+
+    /* sadly, this branch rarely gets taken as the mpv itself is usually
+     * alive. */
+    char *state = scratch->core_info.state;
+    if (!mmbit_any(getActiveLeafArray(t, state), t->activeArrayCount)) {
+        scratch->tctxt.minNonMpvMatchOffset = end;
+        return HWLM_CONTINUE_MATCHING;
+    }
+
+    return roseCatchUpSuf(loc, scratch);
 }
 
 #endif
diff --git a/src/rose/eod.c b/src/rose/eod.c
index 4b22af39..7e8d4b3d 100644
--- a/src/rose/eod.c
+++ b/src/rose/eod.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -28,18 +28,14 @@
 
 #include "catchup.h"
 #include "match.h"
-#include "rose_sidecar_runtime.h"
+#include "program_runtime.h"
 #include "rose.h"
 #include "util/fatbit.h"
 
 static really_inline
-void initContext(const struct RoseEngine *t, u8 *state, u64a offset,
-                 struct hs_scratch *scratch, RoseCallback callback,
-                 RoseCallbackSom som_callback, void *ctx) {
-    struct RoseRuntimeState *rstate = getRuntimeState(state);
+void initContext(const struct RoseEngine *t, char *state, u64a offset,
+                 struct hs_scratch *scratch) {
     struct RoseContext *tctxt = &scratch->tctxt;
-    tctxt->t = t;
-    tctxt->depth = rstate->stored_depth;
     tctxt->groups = loadGroups(t, state); /* TODO: diff groups for eod */
     tctxt->lit_offset_adjust = scratch->core_info.buf_offset
                              - scratch->core_info.hlen
@@ -47,16 +43,10 @@ void initContext(const struct RoseEngine *t, u8 *state, u64a offset,
     tctxt->delayLastEndOffset = offset;
     tctxt->lastEndOffset = offset;
     tctxt->filledDelayedSlots = 0;
-    tctxt->state = state;
-    tctxt->cb = callback;
-    tctxt->cb_som = som_callback;
-    tctxt->userCtx = ctx;
     tctxt->lastMatchOffset = 0;
-    tctxt->minMatchOffset = 0;
-    tctxt->minNonMpvMatchOffset = 0;
-    tctxt->next_mpv_offset = 0;
-    tctxt->curr_anchored_loc = MMB_INVALID;
-    tctxt->curr_row_offset = 0;
+    tctxt->minMatchOffset = offset;
+    tctxt->minNonMpvMatchOffset = offset;
+    tctxt->next_mpv_offset = offset;
 
     scratch->catchup_pq.qm_size = 0;
     scratch->al_log_sum = 0; /* clear the anchored logs */
@@ -88,7 +78,7 @@ hwlmcb_rv_t roseEodRunMatcher(const struct RoseEngine *t, u64a offset,
     if (eod_len < t->eodmatcherMinWidth) {
         DEBUG_PRINTF("len=%zu < eodmatcherMinWidth=%u\n", eod_len,
                      t->eodmatcherMinWidth);
-        return MO_CONTINUE_MATCHING;
+        return HWLM_CONTINUE_MATCHING;
     }
 
     // Ensure that we only need scan the last N bytes, where N is the length of
@@ -98,125 +88,79 @@ hwlmcb_rv_t roseEodRunMatcher(const struct RoseEngine *t, u64a offset,
     DEBUG_PRINTF("eod offset=%llu, eod length=%zu\n", offset, eod_len);
 
     struct RoseContext *tctxt = &scratch->tctxt;
-
-    /* update side_curr for eod_len */
-    tctxt->side_curr = offset - eod_len;
-
-    /* no need to enable any sidecar groups as they are for .*A.* constructs
-     * not allowed in the eod table */
-
     const struct HWLM *etable = getELiteralMatcher(t);
 
-    hwlmExec(etable, eod_data, eod_len, adj, roseCallback, tctxt, tctxt->groups);
+    hwlmExec(etable, eod_data, eod_len, adj, roseCallback, scratch,
+             tctxt->groups);
 
     // We may need to fire delayed matches
-    u8 dummy_delay_mask = 0;
-    return cleanUpDelayed(0, offset, tctxt, &dummy_delay_mask);
+    return cleanUpDelayed(t, scratch, 0, offset);
 }
 
 static rose_inline
-int roseEodRunIterator(const struct RoseEngine *t, u8 *state, u64a offset,
+int roseEodRunIterator(const struct RoseEngine *t, u64a offset,
                        struct hs_scratch *scratch) {
-    if (!t->eodIterOffset) {
+    if (!t->eodIterProgramOffset) {
         return MO_CONTINUE_MATCHING;
     }
 
-    const struct RoseRole *roleTable = getRoleTable(t);
-    const struct RosePred *predTable = getPredTable(t);
-    const struct RoseIterMapping *iterMapBase
-        = getByOffset(t, t->eodIterMapOffset);
-    const struct mmbit_sparse_iter *it = getByOffset(t, t->eodIterOffset);
-    assert(ISALIGNED(iterMapBase));
-    assert(ISALIGNED(it));
+    DEBUG_PRINTF("running eod program at offset %u\n", t->eodIterProgramOffset);
 
-    // Sparse iterator state was allocated earlier
-    struct mmbit_sparse_state *s = scratch->sparse_iter_state;
-    struct fatbit *handled_roles = scratch->handled_roles;
-
-    const u32 numStates = t->rolesWithStateCount;
-
-    void *role_state = getRoleState(state);
-    u32 idx = 0;
-    u32 i = mmbit_sparse_iter_begin(role_state, numStates, &idx, it, s);
-
-    fatbit_clear(handled_roles);
-
-    for (; i != MMB_INVALID;
-           i = mmbit_sparse_iter_next(role_state, numStates, i, &idx, it, s)) {
-        DEBUG_PRINTF("pred state %u (iter idx=%u) is on\n", i, idx);
-        const struct RoseIterMapping *iterMap = iterMapBase + idx;
-        const struct RoseIterRole *roles = getByOffset(t, iterMap->offset);
-        assert(ISALIGNED(roles));
-
-        DEBUG_PRINTF("%u roles to consider\n", iterMap->count);
-        for (u32 j = 0; j != iterMap->count; j++) {
-            u32 role = roles[j].role;
-            assert(role < t->roleCount);
-            DEBUG_PRINTF("checking role %u, pred %u:\n", role, roles[j].pred);
-            const struct RoseRole *tr = roleTable + role;
-
-            if (fatbit_isset(handled_roles, t->roleCount, role)) {
-                DEBUG_PRINTF("role %u already handled by the walk, skip\n",
-                             role);
-                continue;
-            }
-
-            // Special case: if this role is a trivial case (pred type simple)
-            // we don't need to check any history and we already know the pred
-            // role is on.
-            if (tr->flags & ROSE_ROLE_PRED_SIMPLE) {
-                DEBUG_PRINTF("pred type is simple, no need for checks\n");
-            } else {
-                assert(roles[j].pred < t->predCount);
-                const struct RosePred *tp = predTable + roles[j].pred;
-                if (!roseCheckPredHistory(tp, offset)) {
-                    continue;
-                }
-            }
-
-            /* mark role as handled so we don't touch it again in this walk */
-            fatbit_set(handled_roles, t->roleCount, role);
-
-            DEBUG_PRINTF("fire report for role %u, report=%u\n", role,
-                         tr->reportId);
-            int rv = scratch->tctxt.cb(offset, tr->reportId,
-                                       scratch->tctxt.userCtx);
-            if (rv == MO_HALT_MATCHING) {
-                return MO_HALT_MATCHING;
-            }
-        }
+    const u64a som = 0;
+    const size_t match_len = 0;
+    const char in_anchored = 0;
+    const char in_catchup = 0;
+    const char from_mpv = 0;
+    const char skip_mpv_catchup = 1;
+    if (roseRunProgram(t, scratch, t->eodIterProgramOffset, som, offset,
+                       match_len, in_anchored, in_catchup,
+                       from_mpv, skip_mpv_catchup) == HWLM_TERMINATE_MATCHING) {
+        return MO_HALT_MATCHING;
     }
 
     return MO_CONTINUE_MATCHING;
 }
 
+/**
+ * \brief Check for (and deliver) reports from active output-exposed (suffix
+ * or outfix) NFAs.
+ *
+ * \return MO_HALT_MATCHING if the user instructs us to stop.
+ */
 static rose_inline
-void roseCheckNfaEod(const struct RoseEngine *t, u8 *state,
+int roseCheckNfaEod(const struct RoseEngine *t, char *state,
                      struct hs_scratch *scratch, u64a offset,
                      const char is_streaming) {
+    if (!t->eodNfaIterOffset) {
+        DEBUG_PRINTF("no engines that report at EOD\n");
+        return MO_CONTINUE_MATCHING;
+    }
+
     /* data, len is used for state decompress, should be full available data */
-    const u8 *aa = getActiveLeafArray(t, state);
-    const u32 aaCount = t->activeArrayCount;
-
     u8 key = 0;
-
     if (is_streaming) {
         const u8 *eod_data = scratch->core_info.hbuf;
         size_t eod_len = scratch->core_info.hlen;
         key = eod_len ? eod_data[eod_len - 1] : 0;
     }
 
-    for (u32 qi = mmbit_iterate(aa, aaCount, MMB_INVALID); qi != MMB_INVALID;
-         qi = mmbit_iterate(aa, aaCount, qi)) {
+    const u8 *aa = getActiveLeafArray(t, state);
+    const u32 aaCount = t->activeArrayCount;
+
+    const struct mmbit_sparse_iter *it = getByOffset(t, t->eodNfaIterOffset);
+    assert(ISALIGNED(it));
+
+    u32 idx = 0;
+    struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES];
+
+    for (u32 qi = mmbit_sparse_iter_begin(aa, aaCount, &idx, it, si_state);
+         qi != MMB_INVALID;
+         qi = mmbit_sparse_iter_next(aa, aaCount, qi, &idx, it, si_state)) {
         const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
         const struct NFA *nfa = getNfaByInfo(t, info);
 
-        if (!nfaAcceptsEod(nfa)) {
-            DEBUG_PRINTF("nfa %u does not accept eod\n", qi);
-            continue;
-        }
-
         DEBUG_PRINTF("checking nfa %u\n", qi);
+        assert(nfaAcceptsEod(nfa));
 
         char *fstate = scratch->fullState + info->fullStateOffset;
         const char *sstate = (const char *)state + info->stateOffset;
@@ -226,25 +170,26 @@ void roseCheckNfaEod(const struct RoseEngine *t, u8 *state,
             nfaExpandState(nfa, fstate, sstate, offset, key);
         }
 
-        nfaCheckFinalState(nfa, fstate, sstate, offset, scratch->tctxt.cb,
-                           scratch->tctxt.cb_som, scratch->tctxt.userCtx);
+        if (nfaCheckFinalState(nfa, fstate, sstate, offset, roseReportAdaptor,
+                               roseReportSomAdaptor,
+                               scratch) == MO_HALT_MATCHING) {
+            DEBUG_PRINTF("user instructed us to stop\n");
+            return MO_HALT_MATCHING;
+        }
     }
+
+    return MO_CONTINUE_MATCHING;
 }
 
 static rose_inline
-void cleanupAfterEodMatcher(const struct RoseEngine *t, u8 *state, u64a offset,
+void cleanupAfterEodMatcher(const struct RoseEngine *t, u64a offset,
                             struct hs_scratch *scratch) {
-    struct RoseContext *tctxt = &scratch->tctxt;
-
     // Flush history to make sure it's consistent.
-    roseFlushLastByteHistory(t, state, offset, tctxt);
-
-    // Catch up the sidecar to cope with matches raised in the etable.
-    catchup_sidecar(tctxt, offset);
+    roseFlushLastByteHistory(t, scratch, offset);
 }
 
 static rose_inline
-void roseCheckEodSuffixes(const struct RoseEngine *t, u8 *state, u64a offset,
+void roseCheckEodSuffixes(const struct RoseEngine *t, char *state, u64a offset,
                           struct hs_scratch *scratch) {
     const u8 *aa = getActiveLeafArray(t, state);
     const u32 aaCount = t->activeArrayCount;
@@ -274,46 +219,68 @@ void roseCheckEodSuffixes(const struct RoseEngine *t, u8 *state, u64a offset,
          * history buffer. */
         char rv = nfaQueueExecRose(q->nfa, q, MO_INVALID_IDX);
         if (rv) { /* nfa is still alive */
-            nfaCheckFinalState(nfa, fstate, sstate, offset, scratch->tctxt.cb,
-                               scratch->tctxt.cb_som, scratch->tctxt.userCtx);
+            if (nfaCheckFinalState(nfa, fstate, sstate, offset,
+                                   roseReportAdaptor, roseReportSomAdaptor,
+                                   scratch) == MO_HALT_MATCHING) {
+                DEBUG_PRINTF("user instructed us to stop\n");
+                return;
+            }
         }
     }
 }
 
+static rose_inline
+int roseRunEodProgram(const struct RoseEngine *t, u64a offset,
+                      struct hs_scratch *scratch) {
+    if (!t->eodProgramOffset) {
+        return MO_CONTINUE_MATCHING;
+    }
+
+    DEBUG_PRINTF("running eod program at %u\n", t->eodProgramOffset);
+
+    // There should be no pending delayed literals.
+    assert(!scratch->tctxt.filledDelayedSlots);
+
+    const u64a som = 0;
+    const size_t match_len = 0;
+    const char in_anchored = 0;
+    const char in_catchup = 0;
+    const char from_mpv = 0;
+    const char skip_mpv_catchup = 1;
+    if (roseRunProgram(t, scratch, t->eodProgramOffset, som, offset, match_len,
+                       in_anchored, in_catchup, from_mpv,
+                       skip_mpv_catchup) == HWLM_TERMINATE_MATCHING) {
+        return MO_HALT_MATCHING;
+    }
+
+    return MO_CONTINUE_MATCHING;
+}
+
 static really_inline
-void roseEodExec_i(const struct RoseEngine *t, u8 *state, u64a offset,
+void roseEodExec_i(const struct RoseEngine *t, char *state, u64a offset,
                    struct hs_scratch *scratch, const char is_streaming) {
     assert(t);
     assert(scratch->core_info.buf || scratch->core_info.hbuf);
     assert(!scratch->core_info.buf || !scratch->core_info.hbuf);
     assert(!can_stop_matching(scratch));
 
-    // Fire the special EOD event literal.
-    if (t->hasEodEventLiteral) {
-        DEBUG_PRINTF("firing eod event id %u at offset %llu\n",
-                     t->eodLiteralId, offset);
-        const struct core_info *ci = &scratch->core_info;
-        size_t len = ci->buf ? ci->len : ci->hlen;
-        assert(len || !ci->buf); /* len may be 0 if no history is required
-                                  * (bounds checks only can lead to this) */
-
-        roseRunEvent(len, t->eodLiteralId, &scratch->tctxt);
-        if (can_stop_matching(scratch)) {
-            DEBUG_PRINTF("user told us to stop\n");
-            return;
-        }
+    // Run the unconditional EOD program.
+    if (roseRunEodProgram(t, offset, scratch) == MO_HALT_MATCHING) {
+        return;
     }
 
-    roseCheckNfaEod(t, state, scratch, offset, is_streaming);
+    if (roseCheckNfaEod(t, state, scratch, offset, is_streaming) ==
+        MO_HALT_MATCHING) {
+        return;
+    }
 
-    if (!t->eodIterOffset && !t->ematcherOffset) {
+    if (!t->eodIterProgramOffset && !t->ematcherOffset) {
         DEBUG_PRINTF("no eod accepts\n");
         return;
     }
 
     // Handle pending EOD reports.
-    int itrv = roseEodRunIterator(t, state, offset, scratch);
-    if (itrv == MO_HALT_MATCHING) {
+    if (roseEodRunIterator(t, offset, scratch) == MO_HALT_MATCHING) {
         return;
     }
 
@@ -323,34 +290,35 @@ void roseEodExec_i(const struct RoseEngine *t, u8 *state, u64a offset,
         // Unset the reports we just fired so we don't fire them again below.
         mmbit_clear(getRoleState(state), t->rolesWithStateCount);
         mmbit_clear(getActiveLeafArray(t, state), t->activeArrayCount);
-        sidecar_enabled_populate(t, scratch, state);
 
-        hwlmcb_rv_t rv = roseEodRunMatcher(t, offset, scratch, is_streaming);
-        if (rv == HWLM_TERMINATE_MATCHING) {
+        if (roseEodRunMatcher(t, offset, scratch, is_streaming) ==
+            HWLM_TERMINATE_MATCHING) {
             return;
         }
 
-        cleanupAfterEodMatcher(t, state, offset, scratch);
+        cleanupAfterEodMatcher(t, offset, scratch);
 
         // Fire any new EOD reports.
-        roseEodRunIterator(t, state, offset, scratch);
+        if (roseEodRunIterator(t, offset, scratch) == MO_HALT_MATCHING) {
+            return;
+        }
 
         roseCheckEodSuffixes(t, state, offset, scratch);
     }
 }
 
-void roseEodExec(const struct RoseEngine *t, u8 *state, u64a offset,
-                 struct hs_scratch *scratch, RoseCallback callback,
-                 RoseCallbackSom som_callback, void *context) {
-    assert(state);
+void roseEodExec(const struct RoseEngine *t, u64a offset,
+                 struct hs_scratch *scratch) {
     assert(scratch);
-    assert(callback);
-    assert(context);
     assert(t->requiresEodCheck);
     DEBUG_PRINTF("ci buf %p/%zu his %p/%zu\n", scratch->core_info.buf,
                  scratch->core_info.len, scratch->core_info.hbuf,
                  scratch->core_info.hlen);
 
+    // We should not have been called if we've already been told to terminate
+    // matching.
+    assert(!told_to_stop_matching(scratch));
+
     if (t->maxBiAnchoredWidth != ROSE_BOUND_INF
         && offset > t->maxBiAnchoredWidth) {
         DEBUG_PRINTF("bailing, we are beyond max width\n");
@@ -358,19 +326,19 @@ void roseEodExec(const struct RoseEngine *t, u8 *state, u64a offset,
         return;
     }
 
-    initContext(t, state, offset, scratch, callback, som_callback, context);
+    char *state = scratch->core_info.state;
+    assert(state);
+
+    initContext(t, state, offset, scratch);
 
     roseEodExec_i(t, state, offset, scratch, 1);
 }
 
 static rose_inline
-void prepForEod(const struct RoseEngine *t, u8 *state, size_t length,
-                struct RoseContext *tctxt) {
-    roseFlushLastByteHistory(t, state, length, tctxt);
-    tctxt->lastEndOffset = length;
-    if (t->requiresEodSideCatchup) {
-        catchup_sidecar(tctxt, length);
-    }
+void prepForEod(const struct RoseEngine *t, struct hs_scratch *scratch,
+                size_t length) {
+    roseFlushLastByteHistory(t, scratch, length);
+    scratch->tctxt.lastEndOffset = length;
 }
 
 void roseBlockEodExec(const struct RoseEngine *t, u64a offset,
@@ -381,10 +349,10 @@ void roseBlockEodExec(const struct RoseEngine *t, u64a offset,
 
     assert(!can_stop_matching(scratch));
 
-    u8 *state = (u8 *)scratch->core_info.state;
+    char *state = scratch->core_info.state;
 
     // Ensure that history is correct before we look for EOD matches
-    prepForEod(t, state, scratch->core_info.len, &scratch->tctxt);
+    prepForEod(t, scratch, scratch->core_info.len);
 
     roseEodExec_i(t, state, offset, scratch, 0);
 }
diff --git a/src/rose/infix.h b/src/rose/infix.h
index 785d6354..9cf9c0ad 100644
--- a/src/rose/infix.h
+++ b/src/rose/infix.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -32,6 +32,7 @@
 #include "ue2common.h"
 #include "nfa/nfa_api.h"
 #include "nfa/nfa_api_queue.h"
+#include "nfa/nfa_internal.h"
 
 static really_inline
 int infixTooOld(struct mq *q, s64a curr_loc) {
@@ -44,6 +45,26 @@ int infixTooOld(struct mq *q, s64a curr_loc) {
     return q_last_loc(q) + maxAge < curr_loc;
 }
 
+static really_inline
+int canReduceQueue(const struct mq *q, s64a curr_loc, u32 maxTops, u32 maxAge) {
+    u32 qlen = q->end - q->cur; /* includes MQE_START */
+
+    if (maxAge && q->items[q->cur].location + maxAge < curr_loc) {
+        return 1;
+    }
+
+    if (qlen - 1 > maxTops) {
+        return 1;
+    }
+
+    if (qlen - 1 == maxTops
+        && q->items[q->cur].location != q->items[q->cur + 1].location) {
+        /* we can advance start to the first top location */
+        return 1;
+    }
+
+    return 0;
+}
 
 /**
  * Removes tops which are known not to affect the final state from the queue.
@@ -63,28 +84,14 @@ int infixTooOld(struct mq *q, s64a curr_loc) {
  * engine.
  */
 static really_inline
-void reduceQueue(struct mq *q, s64a curr_loc, u32 maxTops, u32 maxAge) {
+void reduceInfixQueue(struct mq *q, s64a curr_loc, u32 maxTops, u32 maxAge) {
     assert(q->end > q->cur);
     assert(maxTops);
     u32 qlen = q->end - q->cur; /* includes MQE_START */
     DEBUG_PRINTF("q=%p, len=%u, maxTops=%u maxAge=%u\n", q, qlen, maxTops,
                  maxAge);
-    char any_work = 0;
-    if (maxAge && q->items[q->cur].location + maxAge < curr_loc) {
-        any_work = 1;
-    }
 
-    if (qlen - 1 > maxTops) {
-        any_work = 1;
-    }
-
-    if (qlen - 1 == maxTops
-        && q->items[q->cur].location != q->items[q->cur + 1].location) {
-        /* we can advance start to the first top location */
-        any_work = 1;
-    }
-
-    if (!any_work) {
+    if (!canReduceQueue(q, curr_loc, maxTops, maxAge)) {
         DEBUG_PRINTF("nothing to do\n");
         return;
     }
diff --git a/src/rose/init.c b/src/rose/init.c
index e87210b7..511eafe4 100644
--- a/src/rose/init.c
+++ b/src/rose/init.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -37,41 +37,19 @@
 #include "nfa/mcclellan.h"
 #include "nfa/nfa_api_util.h"
 #include "nfa/nfa_internal.h"
-#include "sidecar/sidecar.h"
-#include "sidecar/sidecar_internal.h"
 #include "util/multibit.h"
 
 #include <string.h>
 
 static really_inline
-void init_rstate(const struct RoseEngine *t, u8 *state) {
-    // Set runtime state: initial depth is 1 and we take our initial groups
-    // from the RoseEngine.
+void init_rstate(const struct RoseEngine *t, char *state) {
+    // Set runtime state: we take our initial groups from the RoseEngine.
     DEBUG_PRINTF("setting initial groups to 0x%016llx\n", t->initialGroups);
-    struct RoseRuntimeState *rstate = getRuntimeState(state);
-    rstate->stored_depth = 1;
     storeGroups(t, state, t->initialGroups);
-    rstate->flags = 0;
-    rstate->broken = NOT_BROKEN;
 }
 
 static really_inline
-void init_sidecar(const struct RoseEngine *t, u8 *state) {
-    assert(getSLiteralMatcher(t));
-
-    struct sidecar_enabled *enabled_state
-        = (struct sidecar_enabled *)(state + t->stateOffsets.sidecar);
-
-    DEBUG_PRINTF("welcome to the sidecar\n");
-    assert(t->initSideEnableOffset);
-    // We have to enable some sidecar literals
-    const char *template = (const char *)t + t->initSideEnableOffset;
-
-    memcpy(enabled_state, template, t->stateOffsets.sidecar_size);
-}
-
-static really_inline
-void init_outfixes(const struct RoseEngine *t, u8 *state) {
+void init_outfixes(const struct RoseEngine *t, char *state) {
     /* The active leaf array has been init'ed by the scatter with outfix
      * bits set on */
 
@@ -93,23 +71,18 @@ void init_outfixes(const struct RoseEngine *t, u8 *state) {
     }
 }
 
-void roseInitState(const struct RoseEngine *t, u8 *state) {
+void roseInitState(const struct RoseEngine *t, char *state) {
     assert(t);
     assert(state);
 
-    DEBUG_PRINTF("init for Rose %p with %u roles (%u with state indices)\n",
-                 t, t->roleCount, t->rolesWithStateCount);
+    DEBUG_PRINTF("init for Rose %p with %u state indices)\n", t,
+                 t->rolesWithStateCount);
 
     // Rose is guaranteed 8-aligned state
     assert(ISALIGNED_N(state, 8));
 
     init_rstate(t, state);
 
-    // Init the sidecar state
-    if (t->smatcherOffset) {
-        init_sidecar(t, state);
-    }
-
     init_state(t, state);
     init_outfixes(t, state);
 
diff --git a/src/rose/init.h b/src/rose/init.h
index 9aee0586..b37053b2 100644
--- a/src/rose/init.h
+++ b/src/rose/init.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -39,7 +39,7 @@
  */
 
 static really_inline
-void init_state(const struct RoseEngine *t, u8 *state) {
+void init_state(const struct RoseEngine *t, char *state) {
     scatter(state, t, &t->state_init);
 }
 
diff --git a/src/rose/match.c b/src/rose/match.c
index be9bc35e..4e9e72a6 100644
--- a/src/rose/match.c
+++ b/src/rose/match.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -31,7 +31,8 @@
 #include "infix.h"
 #include "match.h"
 #include "miracle.h"
-#include "rose_sidecar_runtime.h"
+#include "program_runtime.h"
+#include "rose_program.h"
 #include "rose.h"
 #include "som/som_runtime.h"
 #include "util/bitutils.h"
@@ -70,129 +71,12 @@ void printMatch(const struct core_info *ci, u64a start, u64a end) {
 }
 #endif
 
-static rose_inline
-int roseCheckBenefits(struct RoseContext *tctxt, u64a end, u32 mask_rewind,
-                      const u8 *and_mask, const u8 *exp_mask) {
-    DEBUG_PRINTF("am offset = %zu, em offset = %zu\n",
-                 and_mask - (const u8 *)tctxt->t,
-                 exp_mask - (const u8 *)tctxt->t);
-    const u8 *data;
-
-    // If the check works over part of the history and part of the buffer, we
-    // create a temporary copy of the data in here so it's contiguous.
-    u8 temp[MAX_MASK2_WIDTH];
-
-    struct core_info *ci = &tctxtToScratch(tctxt)->core_info;
-    s64a buffer_offset = (s64a)end - ci->buf_offset;
-    DEBUG_PRINTF("rel offset %lld\n", buffer_offset);
-    if (buffer_offset >= mask_rewind) {
-        data = ci->buf + buffer_offset - mask_rewind;
-        DEBUG_PRINTF("all in one case data=%p buf=%p rewind=%u\n", data,
-                     ci->buf, mask_rewind);
-    } else if (buffer_offset <= 0) {
-        data = ci->hbuf + ci->hlen + buffer_offset - mask_rewind;
-        DEBUG_PRINTF("all in one case data=%p buf=%p rewind=%u\n", data,
-                     ci->buf, mask_rewind);
-    } else {
-        u32 shortfall = mask_rewind - buffer_offset;
-        DEBUG_PRINTF("shortfall of %u, rewind %u hlen %zu\n", shortfall,
-                     mask_rewind, ci->hlen);
-        data = temp;
-        memcpy(temp, ci->hbuf + ci->hlen - shortfall, shortfall);
-        memcpy(temp + shortfall, ci->buf, mask_rewind - shortfall);
-    }
-
-#ifdef DEBUG
-    DEBUG_PRINTF("DATA: ");
-    for (u32 i = 0; i < mask_rewind; i++) {
-        printf("%c", ourisprint(data[i]) ? data[i] : '?');
-    }
-    printf(" (len=%u)\n", mask_rewind);
-#endif
-
-    u32 len = mask_rewind;
-    while (len >= sizeof(u64a)) {
-        u64a a = unaligned_load_u64a(data);
-        a &= *(const u64a *)and_mask;
-        if (a != *(const u64a *)exp_mask) {
-            DEBUG_PRINTF("argh %016llx %016llx\n", a, *(const u64a *)exp_mask);
-            return 0;
-        }
-        data += sizeof(u64a);
-        and_mask += sizeof(u64a);
-        exp_mask += sizeof(u64a);
-        len -= sizeof(u64a);
-    }
-
-    while (len) {
-        u8 a = *data;
-        a &= *and_mask;
-        if (a != *exp_mask) {
-            DEBUG_PRINTF("argh d%02hhx =%02hhx am%02hhx  em%02hhx\n", a,
-                          *data, *and_mask, *exp_mask);
-            return 0;
-        }
-        data++;
-        and_mask++;
-        exp_mask++;
-        len--;
-    }
-
-    return 1;
-}
-
-static
-int roseCheckLiteralBenefits(u64a end, size_t mask_rewind, u32 id,
-                             struct RoseContext *tctxt) {
-    const struct RoseEngine *t = tctxt->t;
-    const struct lit_benefits *lbi = getLiteralBenefitsTable(t) + id;
-    return roseCheckBenefits(tctxt, end, mask_rewind, lbi->and_mask.a8,
-                             lbi->expected.e8);
-}
-
-static rose_inline
-void pushDelayedMatches(const struct RoseLiteral *tl, u64a offset,
-                        struct RoseContext *tctxt) {
-    u32 delay_mask = tl->delay_mask;
-    if (!delay_mask) {
-        return;
-    }
-
-    u32 delay_count = tctxt->t->delay_count;
-    u8 *delaySlotBase = getDelaySlots(tctxtToScratch(tctxt));
-    size_t delaySlotSize = tctxt->t->delay_slot_size;
-    assert(tl->delayIdsOffset != ROSE_OFFSET_INVALID);
-    const u32 *delayIds = getByOffset(tctxt->t, tl->delayIdsOffset);
-    assert(ISALIGNED(delayIds));
-
-    while (delay_mask) {
-        u32 src_slot_index = findAndClearLSB_32(&delay_mask);
-        u32 slot_index = (src_slot_index + offset) & DELAY_MASK;
-        u8 *slot = delaySlotBase + delaySlotSize * slot_index;
-
-        if (offset + src_slot_index <= tctxt->delayLastEndOffset) {
-            DEBUG_PRINTF("skip too late\n");
-            goto next;
-        }
-
-        DEBUG_PRINTF("pushing tab %u into slot %u\n", *delayIds, slot_index);
-        if (!(tctxt->filledDelayedSlots & (1U << slot_index))) {
-            tctxt->filledDelayedSlots |= 1U << slot_index;
-            mmbit_clear(slot, delay_count);
-        }
-
-        mmbit_set(slot, delay_count, *delayIds);
-    next:
-        delayIds++;
-    }
-}
-
 hwlmcb_rv_t roseDelayRebuildCallback(size_t start, size_t end, u32 id,
                                      void *ctx) {
     struct hs_scratch *scratch = ctx;
     struct RoseContext *tctx = &scratch->tctxt;
-    const struct RoseEngine *t = tctx->t;
     struct core_info *ci = &scratch->core_info;
+    const struct RoseEngine *t = ci->rose;
     size_t rb_len = MIN(ci->hlen, t->delayRebuildLength);
 
     u64a real_end = ci->buf_offset - rb_len + end + 1; // index after last byte
@@ -204,322 +88,74 @@ hwlmcb_rv_t roseDelayRebuildCallback(size_t start, size_t end, u32 id,
     printf("\n");
 #endif
 
-    DEBUG_PRINTF("STATE depth=%u, groups=0x%016llx\n", tctx->depth,
-                 tctx->groups);
-
-    if (isLiteralDR(id)) {
-        return tctx->groups;
-    }
-
-    if (id < t->nonbenefits_base_id
-        && !roseCheckLiteralBenefits(real_end, end - start + 1, id, tctx)) {
-        return tctx->groups;
-    }
+    DEBUG_PRINTF("STATE groups=0x%016llx\n", tctx->groups);
 
+    const u32 *delayRebuildPrograms =
+        getByOffset(t, t->litDelayRebuildProgramOffset);
     assert(id < t->literalCount);
-    const struct RoseLiteral *tl = &getLiteralTable(t)[id];
+    const u32 program = delayRebuildPrograms[id];
 
-    DEBUG_PRINTF("literal id=%u, minDepth=%u, groups=0x%016llx\n",
-                 id, tl->minDepth, tl->groups);
+    if (program) {
+        const u64a som = 0;
+        const size_t match_len = end - start + 1;
+        const char in_anchored = 0;
+        const char in_catchup = 0;
+        const char from_mpv = 0;
+        const char skip_mpv_catchup = 0;
+        UNUSED hwlmcb_rv_t rv =
+            roseRunProgram(t, scratch, program, som, real_end, match_len,
+                           in_anchored, in_catchup, from_mpv, skip_mpv_catchup);
+        assert(rv != HWLM_TERMINATE_MATCHING);
+    }
 
-    pushDelayedMatches(tl, real_end, tctx);
-
-    /* we are just repopulating the delay queue, groups and depths should be
+    /* we are just repopulating the delay queue, groups should be
      * already set from the original scan. */
 
     return tctx->groups;
 }
 
-/* Note: uses the stashed sparse iter state; cannot be called from
- * anybody else who is using it
- */
-static never_inline
-void roseSquashStates(const struct RoseEngine *t, const struct RoseSide *tsb,
-                      struct RoseContext *tctxt) {
-    DEBUG_PRINTF("attempting to squash states\n");
-
-    struct mmbit_sparse_state *s = tctxtToScratch(tctxt)->sparse_iter_state;
-    u8 *state = tctxt->state;
-    void *role_state = getRoleState(state);
-    u32 role_count = t->rolesWithStateCount;
-    const struct mmbit_sparse_iter *it = getByOffset(t, tsb->squashIterOffset);
-    assert(ISALIGNED(it));
-
-    /* we can squash willy-nilly */
-    DEBUG_PRINTF("squashing iter off = %u\n", tsb->squashIterOffset);
-    mmbit_sparse_iter_unset(role_state, role_count, it, s);
-    DEBUG_PRINTF("squashing groups with = %016llx\n", tsb->squashGroupMask);
-    tctxt->groups &= tsb->squashGroupMask;
-}
-
-static really_inline
-hwlmcb_rv_t ensureQueueFlushed_i(const struct RoseEngine *t,
-                                 struct hs_scratch *scratch, u32 qi, s64a loc,
-                                 char is_mpv, char in_anchored,
-                                 char in_catchup) {
-    struct RoseContext *tctxt = &scratch->tctxt;
-    u8 *aa = getActiveLeafArray(t, tctxt->state);
-    struct fatbit *activeQueues = scratch->aqa;
-    u32 aaCount = t->activeArrayCount;
-    u32 qCount = t->queueCount;
-
-    struct mq *q = &scratch->queues[qi];
-    DEBUG_PRINTF("qcl %lld, loc: %lld, min (non mpv) match offset: %llu\n",
-                 q_cur_loc(q), loc, tctxt->minNonMpvMatchOffset);
-    if (q_cur_loc(q) == loc) {
-        /* too many tops enqueued at the one spot; need to flatten this queue.
-         * We can use the full catchups as it will short circuit as we are
-         * already at this location. It also saves waking everybody up */
-        pushQueueNoMerge(q, MQE_END, loc);
-        nfaQueueExec(q->nfa, q, loc);
-        q->cur = q->end = 0;
-        pushQueueAt(q, 0, MQE_START, loc);
-    } else if (!in_catchup) {
-        if (is_mpv) {
-            tctxt->next_mpv_offset = 0; /* force us to catch the mpv */
-            if (loc + scratch->core_info.buf_offset
-                <= tctxt->minNonMpvMatchOffset) {
-                DEBUG_PRINTF("flushing chained\n");
-                if (roseCatchUpMPV(t, tctxt->state, loc, scratch)
-                    == HWLM_TERMINATE_MATCHING) {
-                    return HWLM_TERMINATE_MATCHING;
-                }
-                goto done_queue_empty;
-            }
-        }
-
-        if (roseCatchUpTo(t, tctxt->state, loc + scratch->core_info.buf_offset,
-                          scratch, in_anchored)
-            == HWLM_TERMINATE_MATCHING) {
-            return HWLM_TERMINATE_MATCHING;
-        }
-    } else {
-        /* we must be a chained nfa */
-        assert(is_mpv);
-        DEBUG_PRINTF("flushing chained\n");
-        tctxt->next_mpv_offset = 0; /* force us to catch the mpv */
-        if (roseCatchUpMPV(t, tctxt->state, loc, scratch)
-            == HWLM_TERMINATE_MATCHING) {
-            return HWLM_TERMINATE_MATCHING;
-        }
-    }
-done_queue_empty:
-    if (!mmbit_set(aa, aaCount, qi)) {
-        initQueue(q, qi, t, tctxt);
-        nfaQueueInitState(q->nfa, q);
-        pushQueueAt(q, 0, MQE_START, loc);
-        fatbit_set(activeQueues, qCount, qi);
-    }
-
-    assert(!isQueueFull(q));
-
-    if (isAllExhausted(t, scratch->core_info.exhaustionVector)) {
-        if (!scratch->core_info.broken) {
-            scratch->core_info.broken = BROKEN_EXHAUSTED;
-        }
-        tctxt->groups = 0;
-        DEBUG_PRINTF("termination requested\n");
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    return HWLM_CONTINUE_MATCHING;
-}
-
-static really_inline
-hwlmcb_rv_t ensureQueueFlushed(const struct RoseEngine *t,
-                               struct hs_scratch *scratch, u32 qi, s64a loc,
-                               char in_anchored) {
-    return ensureQueueFlushed_i(t, scratch, qi, loc, 0, in_anchored, 0);
-}
-
 static really_inline
 hwlmcb_rv_t ensureMpvQueueFlushed(const struct RoseEngine *t,
                                   struct hs_scratch *scratch, u32 qi, s64a loc,
-                                  char in_anchored, char in_chained) {
-    return ensureQueueFlushed_i(t, scratch, qi, loc, 1, in_anchored,
-                                in_chained);
+                                  char in_chained) {
+    return ensureQueueFlushed_i(t, scratch, qi, loc, 1, in_chained);
 }
 
 static rose_inline
-hwlmcb_rv_t roseHandleSuffixTrigger(const struct RoseEngine *t,
-                                    const struct RoseRole *tr, u64a som,
-                                    u64a end, struct RoseContext *tctxt,
-                                    char in_anchored) {
-    DEBUG_PRINTF("woot we have a mask/follower/suffix/... role\n");
-
-    assert(tr->suffixOffset);
-
-    const struct NFA *nfa
-        = (const struct NFA *)((const char *)t + tr->suffixOffset);
-    u8 *aa = getActiveLeafArray(t, tctxt->state);
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-    u32 aaCount = t->activeArrayCount;
-    u32 qCount = t->queueCount;
-    u32 qi = nfa->queueIndex;
-    struct mq *q = &scratch->queues[qi];
-    const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
-
-    struct core_info *ci = &scratch->core_info;
-    s64a loc = (s64a)end - ci->buf_offset;
-    assert(loc <= (s64a)ci->len && loc >= -(s64a)ci->hlen);
-
-    if (!mmbit_set(aa, aaCount, qi)) {
-        initQueue(q, qi, t, tctxt);
-        nfaQueueInitState(nfa, q);
-        pushQueueAt(q, 0, MQE_START, loc);
-        fatbit_set(scratch->aqa, qCount, qi);
-    } else if (info->no_retrigger) {
-        DEBUG_PRINTF("yawn\n");
-        /* nfa only needs one top; we can go home now */
-        return HWLM_CONTINUE_MATCHING;
-    } else if (!fatbit_set(scratch->aqa, qCount, qi)) {
-        initQueue(q, qi, t, tctxt);
-        loadStreamState(nfa, q, 0);
-        pushQueueAt(q, 0, MQE_START, 0);
-    } else if (isQueueFull(q)) {
-        DEBUG_PRINTF("queue %u full -> catching up nfas\n", qi);
-        if (info->eod) {
-            /* can catch up suffix independently no pq */
-            q->context = NULL;
-            pushQueueNoMerge(q, MQE_END, loc);
-            nfaQueueExecRose(q->nfa, q, MO_INVALID_IDX);
-            q->cur = q->end = 0;
-            pushQueueAt(q, 0, MQE_START, loc);
-        } else if (ensureQueueFlushed(t, scratch, qi, loc, in_anchored)
-            == HWLM_TERMINATE_MATCHING) {
-            return HWLM_TERMINATE_MATCHING;
-        }
-    }
-
-    u32 top = tr->suffixEvent;
-    assert(top == MQE_TOP || (top >= MQE_TOP_FIRST && top < MQE_INVALID));
-    pushQueueSom(q, top, loc, som);
-
-    if (q_cur_loc(q) == (s64a)ci->len && !info->eod) {
-        /* we may not run the nfa; need to ensure state is fine  */
-        DEBUG_PRINTF("empty run\n");
-        pushQueueNoMerge(q, MQE_END, loc);
-        char alive = nfaQueueExec(nfa, q, loc);
-        if (alive) {
-            q->cur = q->end = 0;
-            pushQueueAt(q, 0, MQE_START, loc);
-        } else {
-            mmbit_unset(aa, aaCount, qi);
-            fatbit_unset(scratch->aqa, qCount, qi);
-        }
-    }
-
-    return HWLM_CONTINUE_MATCHING;
-}
-
-static rose_inline
-void recordAnchoredMatch(struct RoseContext *tctxt, ReportID reportId,
-                         u64a end) {
-    const struct RoseEngine *t = tctxt->t;
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-    u8 **anchoredRows = getAnchoredLog(scratch);
-
-    DEBUG_PRINTF("record %u @ %llu\n", reportId, end);
-    assert(end - t->maxSafeAnchoredDROffset >= 1);
-    u32 adj_end = end - t->maxSafeAnchoredDROffset - 1;
-    DEBUG_PRINTF("adjusted location %u/%u\n", adj_end,
-                  scratch->anchored_region_len);
-
-    if (!bf64_set(&scratch->am_log_sum, adj_end)) {
-        // first time, clear row
-        mmbit_clear(anchoredRows[adj_end], t->anchoredMatches);
-    }
-
-    u32 idx = getAnchoredInverseMap(t)[reportId];
-    DEBUG_PRINTF("record %u @ %llu index %u\n", reportId, end, idx);
-    assert(idx < t->anchoredMatches);
-    mmbit_set(anchoredRows[adj_end], t->anchoredMatches, idx);
-}
-
-static rose_inline
-void recordAnchoredLiteralMatch(struct RoseContext *tctxt, u32 literal_id,
+void recordAnchoredLiteralMatch(const struct RoseEngine *t,
+                                struct hs_scratch *scratch, u32 literal_id,
                                 u64a end) {
     assert(end);
-    const struct RoseEngine *t = tctxt->t;
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-    u8 **anchoredLiteralRows = getAnchoredLiteralLog(scratch);
+    struct fatbit **anchoredLiteralRows = getAnchoredLiteralLog(scratch);
 
     DEBUG_PRINTF("record %u @ %llu\n", literal_id, end);
 
     if (!bf64_set(&scratch->al_log_sum, end - 1)) {
         // first time, clear row
         DEBUG_PRINTF("clearing %llu/%u\n", end - 1, t->anchored_count);
-        mmbit_clear(anchoredLiteralRows[end - 1], t->anchored_count);
+        fatbit_clear(anchoredLiteralRows[end - 1]);
     }
 
     u32 rel_idx = literal_id - t->anchored_base_id;
     DEBUG_PRINTF("record %u @ %llu index %u/%u\n", literal_id, end, rel_idx,
                  t->anchored_count);
     assert(rel_idx < t->anchored_count);
-    mmbit_set(anchoredLiteralRows[end - 1], t->anchored_count, rel_idx);
+    fatbit_set(anchoredLiteralRows[end - 1], t->anchored_count, rel_idx);
 }
 
-/* handles the firing of external matches */
-static rose_inline
-hwlmcb_rv_t roseHandleMatch(const struct RoseEngine *t, u8 *state, ReportID id,
-                            u64a end, struct RoseContext *tctxt,
-                            char in_anchored) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    if (roseCatchUpTo(t, state, end, scratch, in_anchored)
-        == HWLM_TERMINATE_MATCHING) {
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    assert(end == tctxt->minMatchOffset);
-    DEBUG_PRINTF("firing callback reportId=%u, end=%llu\n", id, end);
-    updateLastMatchOffset(tctxt, end);
-
-    int cb_rv = tctxt->cb(end, id, tctxt->userCtx);
-    if (cb_rv == MO_HALT_MATCHING) {
-        DEBUG_PRINTF("termination requested\n");
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
-        return HWLM_CONTINUE_MATCHING;
-    }
-
-    if (isAllExhausted(t, scratch->core_info.exhaustionVector)) {
-        if (!scratch->core_info.broken) {
-            scratch->core_info.broken = BROKEN_EXHAUSTED;
-        }
-        tctxt->groups = 0;
-        DEBUG_PRINTF("termination requested\n");
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    return HWLM_CONTINUE_MATCHING;
-}
-
-hwlmcb_rv_t roseHandleChainMatch(const struct RoseEngine *t, ReportID r,
-                                 u64a end, struct RoseContext *tctxt,
-                                 char in_anchored, char in_catchup) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
+hwlmcb_rv_t roseHandleChainMatch(const struct RoseEngine *t,
+                                 struct hs_scratch *scratch, u32 event,
+                                 u64a top_squash_distance, u64a end,
+                                 char in_catchup) {
+    assert(event == MQE_TOP || event >= MQE_TOP_FIRST);
     struct core_info *ci = &scratch->core_info;
 
-    u8 *aa = getActiveLeafArray(t, tctxt->state);
+    u8 *aa = getActiveLeafArray(t, scratch->core_info.state);
     u32 aaCount = t->activeArrayCount;
     struct fatbit *activeQueues = scratch->aqa;
     u32 qCount = t->queueCount;
 
-    const struct internal_report *ri = getInternalReport(t, r);
-    assert(ri->type == INTERNAL_ROSE_CHAIN);
-
-    u32 qi = 0; /* MPV is always queue 0 if it exists */
-    u32 event = ri->onmatch;
-    assert(event == MQE_TOP || event >= MQE_TOP_FIRST);
-
-    /* TODO: populate INTERNAL_ROSE_CHAIN internal reports with offset where
-     * possible */
-    if (end < ri->minOffset || (ri->maxOffset && end > ri->maxOffset)) {
-        return HWLM_CONTINUE_MATCHING;
-    }
+    const u32 qi = 0; /* MPV is always queue 0 if it exists */
     struct mq *q = &scratch->queues[qi];
     const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
 
@@ -527,7 +163,7 @@ hwlmcb_rv_t roseHandleChainMatch(const struct RoseEngine *t, ReportID r,
     assert(loc <= (s64a)ci->len && loc >= -(s64a)ci->hlen);
 
     if (!mmbit_set(aa, aaCount, qi)) {
-        initQueue(q, qi, t, tctxt);
+        initQueue(q, qi, t, scratch);
         nfaQueueInitState(q->nfa, q);
         pushQueueAt(q, 0, MQE_START, loc);
         fatbit_set(activeQueues, qCount, qi);
@@ -536,24 +172,25 @@ hwlmcb_rv_t roseHandleChainMatch(const struct RoseEngine *t, ReportID r,
         /* nfa only needs one top; we can go home now */
         return HWLM_CONTINUE_MATCHING;
     } else if (!fatbit_set(activeQueues, qCount, qi)) {
-        initQueue(q, qi, t, tctxt);
+        initQueue(q, qi, t, scratch);
         loadStreamState(q->nfa, q, 0);
         pushQueueAt(q, 0, MQE_START, 0);
     } else if (isQueueFull(q)) {
         DEBUG_PRINTF("queue %u full -> catching up nfas\n", qi);
         /* we know it is a chained nfa and the suffixes/outfixes must already
          * be known to be consistent */
-        if (ensureMpvQueueFlushed(t, scratch, qi, loc, in_anchored, in_catchup)
+        if (ensureMpvQueueFlushed(t, scratch, qi, loc, in_catchup)
             == HWLM_TERMINATE_MATCHING) {
+            DEBUG_PRINTF("terminating...\n");
             return HWLM_TERMINATE_MATCHING;
         }
     }
 
-    if (ri->aux.topSquashDistance) {
+    if (top_squash_distance) {
         assert(q->cur != q->end);
         struct mq_item *last = &q->items[q->end - 1];
         if (last->type == event
-            && last->location >= loc - (s64a)ri->aux.topSquashDistance) {
+            && last->location >= loc - (s64a)top_squash_distance) {
             last->location = loc;
             goto event_enqueued;
         }
@@ -568,7 +205,7 @@ event_enqueued:
         pushQueueNoMerge(q, MQE_END, loc);
         char alive = nfaQueueExec(q->nfa, q, loc);
         if (alive) {
-            tctxt->mpv_inactive = 0;
+            scratch->tctxt.mpv_inactive = 0;
             q->cur = q->end = 0;
             pushQueueAt(q, 0, MQE_START, loc);
         } else {
@@ -578,1056 +215,28 @@ event_enqueued:
     }
 
     DEBUG_PRINTF("added mpv event at %lld\n", loc);
-    tctxt->next_mpv_offset = 0; /* the top event may result in matches earlier
-                                 * than expected */
+    scratch->tctxt.next_mpv_offset = 0; /* the top event may result in matches
+                                         * earlier than expected */
     return HWLM_CONTINUE_MATCHING;
 }
 
-/* catches up engines enough to ensure any earlier mpv triggers are enqueued
- * and then adds the trigger to the mpv queue. Must not be called during catch
- * up */
-static rose_inline
-hwlmcb_rv_t roseCatchUpAndHandleChainMatch(const struct RoseEngine *t,
-                                           u8 *state, ReportID r, u64a end,
-                                           struct RoseContext *tctxt,
-                                           char in_anchored) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    if (roseCatchUpMpvFeeders(t, state, end, scratch, in_anchored)
-        == HWLM_TERMINATE_MATCHING) {
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    return roseHandleChainMatch(t, r, end, tctxt, in_anchored, 0);
-}
-
-static rose_inline
-hwlmcb_rv_t roseSomCatchup(const struct RoseEngine *t, u8 *state, u64a end,
-                           struct RoseContext *tctxt, char in_anchored) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    // In SOM processing, we may be able to limit or entirely avoid catchup.
-
-    DEBUG_PRINTF("entry\n");
-
-    if (end == tctxt->minMatchOffset) {
-        DEBUG_PRINTF("already caught up\n");
-        return HWLM_CONTINUE_MATCHING;
-    }
-
-    DEBUG_PRINTF("catching up all NFAs\n");
-    if (roseCatchUpTo(t, state, end, scratch, in_anchored)
-        == HWLM_TERMINATE_MATCHING) {
-        return HWLM_TERMINATE_MATCHING;
-    }
-    updateMinMatchOffset(tctxt, end);
-    return HWLM_CONTINUE_MATCHING;
-}
-
-static really_inline
-hwlmcb_rv_t roseHandleSom(const struct RoseEngine *t, u8 *state, ReportID id,
-                          u64a end, struct RoseContext *tctxt,
-                          char in_anchored) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-
-    DEBUG_PRINTF("id=%u, end=%llu, minMatchOffset=%llu\n", id, end,
-                  tctxt->minMatchOffset);
-
-    // Reach into reports and handle internal reports that just manipulate SOM
-    // slots ourselves, rather than going through the callback.
-
-    if (roseSomCatchup(t, state, end, tctxt, in_anchored)
-        == HWLM_TERMINATE_MATCHING) {
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    const struct internal_report *ri = getInternalReport(t, id);
-    handleSomInternal(scratch, ri, end);
-
-    return HWLM_CONTINUE_MATCHING;
-}
-
-static rose_inline
-hwlmcb_rv_t roseHandleSomMatch(const struct RoseEngine *t, u8 *state,
-                               ReportID id, u64a start, u64a end,
-                               struct RoseContext *tctxt, char in_anchored) {
-    if (roseCatchUpTo(t, state, end, tctxtToScratch(tctxt), in_anchored)
-        == HWLM_TERMINATE_MATCHING) {
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    DEBUG_PRINTF("firing som callback reportId=%u, start=%llu end=%llu\n", id,
-                 start, end);
-    DEBUG_PRINTF("    last match %llu\n", tctxt->lastMatchOffset);
-    assert(end == tctxt->minMatchOffset);
-
-    updateLastMatchOffset(tctxt, end);
-    int cb_rv = tctxt->cb_som(start, end, id, tctxt->userCtx);
-    if (cb_rv == MO_HALT_MATCHING) {
-        DEBUG_PRINTF("termination requested\n");
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
-        return HWLM_CONTINUE_MATCHING;
-    }
-
-    struct core_info *ci = &tctxtToScratch(tctxt)->core_info;
-    if (isAllExhausted(t, ci->exhaustionVector)) {
-        if (!ci->broken) {
-            ci->broken = BROKEN_EXHAUSTED;
-        }
-        tctxt->groups = 0;
-        DEBUG_PRINTF("termination requested\n");
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    return HWLM_CONTINUE_MATCHING;
-}
-
-static rose_inline
-hwlmcb_rv_t roseHandleSomSom(const struct RoseEngine *t, u8 *state, ReportID id,
-                             u64a start, u64a end, struct RoseContext *tctxt,
-                             char in_anchored) {
-    DEBUG_PRINTF("id=%u, start=%llu, end=%llu, minMatchOffset=%llu\n",
-                  id, start, end, tctxt->minMatchOffset);
-
-    // Reach into reports and handle internal reports that just manipulate SOM
-    // slots ourselves, rather than going through the callback.
-
-    if (roseSomCatchup(t, state, end, tctxt, in_anchored)
-        == HWLM_TERMINATE_MATCHING) {
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    const struct internal_report *ri = getInternalReport(t, id);
-    setSomFromSomAware(tctxtToScratch(tctxt), ri, start, end);
-    return HWLM_CONTINUE_MATCHING;
-}
-
-static rose_inline
-char rosePrefixCheckMiracles(const struct RoseEngine *t,
-                             const struct LeftNfaInfo *left,
-                             struct core_info *ci, struct mq *q, u64a end) {
-    if (left->transient) {
-        // Miracles won't help us with transient leftfix engines; they only
-        // scan for a limited time anyway.
-        return 1;
-    }
-
-    if (!left->stopTable) {
-        return 1;
-    }
-
-    DEBUG_PRINTF("looking for miracle on queue %u\n", q->nfa->queueIndex);
-
-    const s64a begin_loc = q_cur_loc(q);
-    const s64a end_loc = end - ci->buf_offset;
-
-    s64a miracle_loc;
-    if (roseMiracleOccurs(t, left, ci, begin_loc, end_loc, &miracle_loc)) {
-        goto found_miracle;
-    }
-
-    if (roseCountingMiracleOccurs(t, left, ci, begin_loc, end_loc,
-                                  &miracle_loc)) {
-        goto found_miracle;
-    }
-
-    return 1;
-
-found_miracle:
-    DEBUG_PRINTF("miracle at %lld\n", miracle_loc);
-    assert(miracle_loc >= begin_loc);
-
-    // If we're a prefix, then a miracle effectively results in us needing to
-    // re-init our state and start fresh.
-    if (!left->infix) {
-        if (miracle_loc != begin_loc) {
-            DEBUG_PRINTF("re-init prefix state\n");
-            q->cur = q->end = 0;
-            pushQueueAt(q, 0, MQE_START, miracle_loc);
-            pushQueueAt(q, 1, MQE_TOP, miracle_loc);
-            nfaQueueInitState(q->nfa, q);
-        }
-        return 1;
-    }
-
-    // Otherwise, we're an infix. Remove tops before the miracle from the queue
-    // and re-init at that location.
-
-    q_skip_forward_to(q, miracle_loc);
-
-    if (q_last_type(q) == MQE_START) {
-        DEBUG_PRINTF("miracle caused infix to die\n");
-        return 0;
-    }
-
-    DEBUG_PRINTF("re-init infix state\n");
-    assert(q->items[q->cur].type == MQE_START);
-    q->items[q->cur].location = miracle_loc;
-    nfaQueueInitState(q->nfa, q);
-
-    return 1;
-}
-
-static rose_inline
-char roseTestLeftfix(const struct RoseEngine *t, const struct RoseRole *tr,
-                     u64a end, struct RoseContext *tctxt) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-    struct core_info *ci = &scratch->core_info;
-    assert(tr->flags & ROSE_ROLE_FLAG_ROSE);
-
-    u32 qi = tr->leftfixQueue;
-
-    u32 ri = queueToLeftIndex(t, qi);
-    const struct LeftNfaInfo *left = getLeftTable(t) + ri;
-
-    DEBUG_PRINTF("testing %s %s %u/%u with lag %u (maxLag=%u)\n",
-                 (left->transient ? "transient" : "active"),
-                 (left->infix ? "infix" : "prefix"),
-                 ri, qi, tr->leftfixLag, left->maxLag);
-
-    assert(tr->leftfixLag <= left->maxLag);
-
-    struct mq *q = scratch->queues + qi;
-    u32 qCount = t->queueCount;
-    u32 arCount = t->activeLeftCount;
-
-    if (!mmbit_isset(getActiveLeftArray(t, tctxt->state), arCount, ri)) {
-        DEBUG_PRINTF("engine is dead nothing to see here\n");
-        return 0;
-    }
-
-    if (unlikely(end < tr->leftfixLag)) {
-        assert(0); /* lag is the literal length */
-        return 0;
-    }
-
-    if (nfaSupportsZombie(getNfaByQueue(t, qi)) && ci->buf_offset
-        && !fatbit_isset(scratch->aqa, qCount, qi)
-        && isZombie(t, tctxt->state, left)) {
-        DEBUG_PRINTF("zombie\n");
-        return 1;
-    }
-
-    if (!fatbit_set(scratch->aqa, qCount, qi)) {
-        DEBUG_PRINTF("initing q %u\n", qi);
-        initRoseQueue(t, qi, left, tctxt);
-        if (ci->buf_offset) { // there have been writes before us!
-            s32 sp;
-            if (left->transient) {
-                sp = -(s32)ci->hlen;
-            } else {
-                sp = -(s32)loadRoseDelay(t, tctxt->state, left);
-            }
-
-            /* transient nfas are always started fresh -> state not maintained
-             * at stream boundary */
-
-            pushQueueAt(q, 0, MQE_START, sp);
-            if (left->infix || (ci->buf_offset + sp > 0 && !left->transient)) {
-                loadStreamState(q->nfa, q, sp);
-            } else {
-                pushQueueAt(q, 1, MQE_TOP, sp);
-                nfaQueueInitState(q->nfa, q);
-            }
-        } else { // first write ever
-            pushQueueAt(q, 0, MQE_START, 0);
-            pushQueueAt(q, 1, MQE_TOP, 0);
-            nfaQueueInitState(q->nfa, q);
-        }
-    }
-
-    s64a loc = (s64a)end - ci->buf_offset - tr->leftfixLag;
-    assert(loc >= q_cur_loc(q));
-    assert(tr->leftfixReport != MO_INVALID_IDX);
-
-    if (left->transient) {
-        s64a start_loc = loc - left->transient;
-        if (q_cur_loc(q) < start_loc) {
-            q->cur = q->end = 0;
-            pushQueueAt(q, 0, MQE_START, start_loc);
-            pushQueueAt(q, 1, MQE_TOP, start_loc);
-            nfaQueueInitState(q->nfa, q);
-        }
-    }
-
-    if (q_cur_loc(q) < loc || q_last_type(q) != MQE_START) {
-        if (left->infix) {
-            if (infixTooOld(q, loc)) {
-                DEBUG_PRINTF("infix %u died of old age\n", ri);
-                scratch->tctxt.groups &= left->squash_mask;
-                mmbit_unset(getActiveLeftArray(t, tctxt->state), arCount, ri);
-                return 0;
-            }
-
-            reduceQueue(q, loc, left->maxQueueLen, q->nfa->maxWidth);
-        }
-
-        if (!rosePrefixCheckMiracles(t, left, ci, q, end)) {
-            DEBUG_PRINTF("leftfix %u died due to miracle\n", ri);
-            scratch->tctxt.groups &= left->squash_mask;
-            mmbit_unset(getActiveLeftArray(t, tctxt->state), arCount, ri);
-            return 0;
-        }
-
-#ifdef DEBUG
-        debugQueue(q);
-#endif
-
-        pushQueueNoMerge(q, MQE_END, loc);
-
-        char rv = nfaQueueExecRose(q->nfa, q, tr->leftfixReport);
-        if (!rv) { /* nfa is dead */
-            DEBUG_PRINTF("leftfix %u died while trying to catch up\n", ri);
-            mmbit_unset(getActiveLeftArray(t, tctxt->state), arCount, ri);
-            assert(!mmbit_isset(getActiveLeftArray(t, tctxt->state), arCount,
-                                ri));
-            tctxt->groups &= left->squash_mask;
-            return 0;
-        }
-
-        // Queue must have next start loc before we call nfaInAcceptState.
-        q->cur = q->end = 0;
-        pushQueueAt(q, 0, MQE_START, loc);
-
-        DEBUG_PRINTF("checking for report %u\n", tr->leftfixReport);
-        DEBUG_PRINTF("leftfix done %hhd\n", (signed char)rv);
-        return rv == MO_MATCHES_PENDING;
-    } else {
-        DEBUG_PRINTF("checking for report %u\n", tr->leftfixReport);
-        char rv = nfaInAcceptState(q->nfa, tr->leftfixReport, q);
-        DEBUG_PRINTF("leftfix done %hhd\n", (signed char)rv);
-        return rv;
-    }
-}
-
-static rose_inline
-void roseSetRole(const struct RoseEngine *t, u8 *state,
-                 struct RoseContext *tctxt, const struct RoseRole *tr) {
-    DEBUG_PRINTF("set role %u on: idx=%u, depth=%u, groups=0x%016llx\n",
-                 (u32)(tr - getRoleTable(t)),
-                 tr->stateIndex, tr->depth, tr->groups);
-    void *role_state = getRoleState(state);
-
-    assert(tr < getRoleTable(t) + t->roleCount);
-
-    int leafNode = !!(tr->stateIndex == MMB_INVALID);
-
-    // If this role is a leaf node, it doesn't have a state index to switch
-    // on and it doesn't need any history stored or other work done. So we can
-    // bail.
-    /* may be a ghost role; still need to set groups */
-    if (leafNode) {
-        tctxt->groups |= tr->groups;
-        DEBUG_PRINTF("role %u is a leaf node, no work to do.\n",
-                (u32)(tr - getRoleTable(t)));
-        return;
-    }
-
-    // Switch this role on in the state bitvector, checking whether it was set
-    // already.
-    char alreadySet = mmbit_set(role_state, t->rolesWithStateCount,
-                                tr->stateIndex);
-
-    // Roles that we've already seen have had most of their bookkeeping done:
-    // all we need to do is update the offset table if this is an
-    // offset-tracking role.
-    if (alreadySet) {
-        DEBUG_PRINTF("role already set\n");
-        if (tr->sidecarEnableOffset) {
-            enable_sidecar(tctxt, tr);
-        }
-        return;
-    }
-
-    // If this role's depth is greater than the current depth, update it
-    update_depth(tctxt, tr);
-
-    // Switch on this role's groups
-    tctxt->groups |= tr->groups;
-
-    if (tr->sidecarEnableOffset) {
-        // We have to enable some sidecar literals
-        enable_sidecar(tctxt, tr);
-    }
-}
-
-static rose_inline
-void roseTriggerInfixes(const struct RoseEngine *t, const struct RoseRole *tr,
-                        u64a start, u64a end, struct RoseContext *tctxt) {
-    struct core_info *ci = &tctxtToScratch(tctxt)->core_info;
-
-    DEBUG_PRINTF("infix time! @%llu\t(s%llu)\n", end, start);
-
-    assert(tr->infixTriggerOffset);
-
-    u32 qCount = t->queueCount;
-    u32 arCount = t->activeLeftCount;
-    struct fatbit *aqa = tctxtToScratch(tctxt)->aqa;
-    u8 *activeLeftArray = getActiveLeftArray(t, tctxt->state);
-    s64a loc = (s64a)end - ci->buf_offset;
-
-    const struct RoseTrigger *curr_r = (const struct RoseTrigger *)
-        ((const char *)t + tr->infixTriggerOffset);
-    assert(ISALIGNED_N(curr_r, alignof(struct RoseTrigger)));
-    assert(curr_r->queue != MO_INVALID_IDX); /* shouldn't be here if no
-                                              * triggers */
-    do {
-        u32 qi = curr_r->queue;
-        u32 ri = queueToLeftIndex(t, qi);
-        u32 topEvent = curr_r->event;
-        u8 cancel = curr_r->cancel_prev_top;
-        assert(topEvent < MQE_INVALID);
-
-        const struct LeftNfaInfo *left = getLeftInfoByQueue(t, qi);
-        assert(!left->transient);
-
-        DEBUG_PRINTF("rose %u (qi=%u) event %u\n", ri, qi, topEvent);
-
-        struct mq *q = tctxtToScratch(tctxt)->queues + qi;
-        const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
-
-        char alive = mmbit_set(activeLeftArray, arCount, ri);
-
-        if (alive && info->no_retrigger) {
-            DEBUG_PRINTF("yawn\n");
-            goto next_infix;
-        }
-
-        if (alive && nfaSupportsZombie(getNfaByInfo(t, info)) && ci->buf_offset
-            && !fatbit_isset(aqa, qCount, qi)
-            && isZombie(t, tctxt->state, left)) {
-            DEBUG_PRINTF("yawn - zombie\n");
-            goto next_infix;
-        }
-
-        if (cancel) {
-            DEBUG_PRINTF("dominating top: (re)init\n");
-            fatbit_set(aqa, qCount, qi);
-            initRoseQueue(t, qi, left, tctxt);
-            pushQueueAt(q, 0, MQE_START, loc);
-            nfaQueueInitState(q->nfa, q);
-        } else if (!fatbit_set(aqa, qCount, qi)) {
-            DEBUG_PRINTF("initing %u\n", qi);
-            initRoseQueue(t, qi, left, tctxt);
-            if (alive) {
-                s32 sp = -(s32)loadRoseDelay(t, tctxt->state, left);
-                pushQueueAt(q, 0, MQE_START, sp);
-                loadStreamState(q->nfa, q, sp);
-            } else {
-                pushQueueAt(q, 0, MQE_START, loc);
-                nfaQueueInitState(q->nfa, q);
-            }
-        } else if (!alive) {
-            q->cur = q->end = 0;
-            pushQueueAt(q, 0, MQE_START, loc);
-            nfaQueueInitState(q->nfa, q);
-        } else if (isQueueFull(q)) {
-            reduceQueue(q, loc, left->maxQueueLen, q->nfa->maxWidth);
-
-            if (isQueueFull(q)) {
-                /* still full - reduceQueue did nothing */
-                DEBUG_PRINTF("queue %u full (%u items) -> catching up nfa\n",
-                             qi, q->end - q->cur);
-                pushQueueNoMerge(q, MQE_END, loc);
-                nfaQueueExecRose(q->nfa, q, MO_INVALID_IDX);
-
-                q->cur = q->end = 0;
-                pushQueueAt(q, 0, MQE_START, loc);
-            }
-        }
-
-        pushQueueSom(q, topEvent, loc, start);
-    next_infix:
-        ++curr_r;
-    } while (curr_r->queue != MO_INVALID_IDX);
-}
-
-static really_inline
-int reachHasBit(const u8 *reach, u8 c) {
-    return !!(reach[c / 8U] & (u8)1U << (c % 8U));
-}
-
-/**
- * \brief Scan around a literal, checking that that "lookaround" reach masks
- * are satisfied.
- */
-static rose_inline
-int roseCheckLookaround(const struct RoseEngine *t, const struct RoseRole *tr,
-                        u64a end, struct RoseContext *tctxt) {
-    assert(tr->lookaroundIndex != MO_INVALID_IDX);
-    assert(tr->lookaroundCount > 0);
-
-    const struct core_info *ci = &tctxtToScratch(tctxt)->core_info;
-    DEBUG_PRINTF("end=%llu, buf_offset=%llu, buf_end=%llu\n", end,
-                 ci->buf_offset, ci->buf_offset + ci->len);
-
-    const u8 *base = (const u8 *)t;
-    const s8 *look_base = (const s8 *)(base + t->lookaroundTableOffset);
-    const s8 *look = look_base + tr->lookaroundIndex;
-    const s8 *look_end = look + tr->lookaroundCount;
-    assert(look < look_end);
-
-    const u8 *reach_base = base + t->lookaroundReachOffset;
-    const u8 *reach = reach_base + tr->lookaroundIndex * REACH_BITVECTOR_LEN;
-
-    // The following code assumes that the lookaround structures are ordered by
-    // increasing offset.
-
-    const s64a base_offset = end - ci->buf_offset;
-    DEBUG_PRINTF("base_offset=%lld\n", base_offset);
-    DEBUG_PRINTF("first look has offset %d\n", *look);
-
-    // If our first check tells us we need to look at an offset before the
-    // start of the stream, this role cannot match.
-    if (unlikely(*look < 0 && (u64a)(0 - *look) > end)) {
-        DEBUG_PRINTF("too early, fail\n");
-        return 0;
-    }
-
-    // Skip over offsets that are before the history buffer.
-    do {
-        s64a offset = base_offset + *look;
-        if (offset >= -(s64a)ci->hlen) {
-            goto in_history;
-        }
-        DEBUG_PRINTF("look=%d before history\n", *look);
-        look++;
-        reach += REACH_BITVECTOR_LEN;
-    } while (look < look_end);
-
-    // History buffer.
-    DEBUG_PRINTF("scan history (%zu looks left)\n", look_end - look);
-    for (; look < look_end; ++look, reach += REACH_BITVECTOR_LEN) {
-    in_history:
-        ;
-        s64a offset = base_offset + *look;
-        DEBUG_PRINTF("reach=%p, rel offset=%lld\n", reach, offset);
-
-        if (offset >= 0) {
-            DEBUG_PRINTF("in buffer\n");
-            goto in_buffer;
-        }
-
-        assert(offset >= -(s64a)ci->hlen && offset < 0);
-        u8 c = ci->hbuf[ci->hlen + offset];
-        if (!reachHasBit(reach, c)) {
-            DEBUG_PRINTF("char 0x%02x failed reach check\n", c);
-            return 0;
-        }
-    }
-
-    // Current buffer.
-    DEBUG_PRINTF("scan buffer (%zu looks left)\n", look_end - look);
-    for (; look < look_end; ++look, reach += REACH_BITVECTOR_LEN) {
-    in_buffer:
-        ;
-        s64a offset = base_offset + *look;
-        DEBUG_PRINTF("reach=%p, rel offset=%lld\n", reach, offset);
-
-        if (offset >= (s64a)ci->len) {
-            DEBUG_PRINTF("in the future\n");
-            break;
-        }
-
-        assert(offset >= 0 && offset < (s64a)ci->len);
-        u8 c = ci->buf[offset];
-        if (!reachHasBit(reach, c)) {
-            DEBUG_PRINTF("char 0x%02x failed reach check\n", c);
-            return 0;
-        }
-    }
-
-    DEBUG_PRINTF("OK :)\n");
-    return 1;
-}
-
-static rose_inline
-int roseCheckRolePreconditions(const struct RoseEngine *t,
-                               const struct RoseRole *tr, u64a end,
-                               struct RoseContext *tctxt) {
-    // If this role can only match at end-of-block, then check that it's so.
-    if (tr->flags & ROSE_ROLE_FLAG_ONLY_AT_END) {
-        struct core_info *ci = &tctxtToScratch(tctxt)->core_info;
-        if (end != ci->buf_offset + ci->len) {
-            DEBUG_PRINTF("role %u should only match at end of data, skipping\n",
-                         (u32)(tr - getRoleTable(t)));
-            return 0;
-        }
-    }
-
-    if (tr->lookaroundIndex != MO_INVALID_IDX) {
-        if (!roseCheckLookaround(t, tr, end, tctxt)) {
-            DEBUG_PRINTF("failed lookaround check\n");
-            return 0;
-        }
-    }
-
-    assert(!tr->leftfixQueue || (tr->flags & ROSE_ROLE_FLAG_ROSE));
-    if (tr->flags & ROSE_ROLE_FLAG_ROSE) {
-        if (!roseTestLeftfix(t, tr, end, tctxt)) {
-            DEBUG_PRINTF("failed leftfix check\n");
-            return 0;
-        }
-    }
-
-    return 1;
-}
-
-static
-int roseNfaEarliestSom(u64a from_offset, UNUSED u64a offset, UNUSED ReportID id,
-                       void *context) {
-    u64a *som = context;
-    *som = MIN(*som, from_offset);
-    return MO_CONTINUE_MATCHING;
-}
-
-static rose_inline
-u64a roseGetHaigSom(const struct RoseEngine *t, const struct RoseRole *tr,
-                    UNUSED u64a end, struct RoseContext *tctxt) {
-    assert(tr->flags & ROSE_ROLE_FLAG_ROSE);
-
-    u32 qi = tr->leftfixQueue;
-    u32 ri = queueToLeftIndex(t, qi);
-
-    UNUSED const struct LeftNfaInfo *left = getLeftTable(t) + ri;
-
-    DEBUG_PRINTF("testing %s prefix %u/%u with lag %u (maxLag=%u)\n",
-                 left->transient ? "transient" : "active", ri, qi,
-                 tr->leftfixLag, left->maxLag);
-
-    assert(tr->leftfixLag <= left->maxLag);
-
-    struct mq *q = tctxtToScratch(tctxt)->queues + qi;
-
-    u64a start = ~0ULL;
-
-    /* switch the callback + context for a fun one */
-    q->som_cb = roseNfaEarliestSom;
-    q->context = &start;
-
-    nfaReportCurrentMatches(q->nfa, q);
-
-    /* restore the old callback + context */
-    q->som_cb = roseNfaSomAdaptor;
-    q->context = NULL;
-    DEBUG_PRINTF("earliest som is %llu\n", start);
-    return start;
-}
-
-static really_inline
-hwlmcb_rv_t roseHandleRoleEffects(const struct RoseEngine *t,
-                                  const struct RoseRole *tr, u64a end,
-                                  struct RoseContext *tctxt, char in_anchored,
-                                  int *work_done) {
-    u64a som = 0ULL;
-    if (tr->flags & ROSE_ROLE_FLAG_SOM_ADJUST) {
-        som = end - tr->somAdjust;
-        DEBUG_PRINTF("som requested som %llu = %llu - %u\n", som, end,
-                     tr->somAdjust);
-    } else if (tr->flags & ROSE_ROLE_FLAG_SOM_ROSEFIX) {
-        som = roseGetHaigSom(t, tr, end, tctxt);
-        DEBUG_PRINTF("som from rosefix %llu\n", som);
-    }
-
-    if (tr->infixTriggerOffset) {
-        roseTriggerInfixes(t, tr, som, end, tctxt);
-        tctxt->groups |= tr->groups; /* groups may have been cleared by infix
-                                      * going quiet before */
-    }
-
-    if (tr->suffixOffset) {
-        hwlmcb_rv_t rv = roseHandleSuffixTrigger(t, tr, som, end, tctxt,
-                                                 in_anchored);
-        if (rv != HWLM_CONTINUE_MATCHING) {
-            return rv;
-        }
-    }
-
-    if (tr->reportId != MO_INVALID_IDX) {
-        hwlmcb_rv_t rv;
-        if (tr->flags & ROSE_ROLE_FLAG_REPORT_START) {
-            /* rose role knows its start offset */
-            assert(tr->flags & ROSE_ROLE_FLAG_SOM_ROSEFIX);
-            assert(!(tr->flags & ROSE_ROLE_FLAG_CHAIN_REPORT));
-            if (tr->flags & ROSE_ROLE_FLAG_SOM_REPORT) {
-                rv = roseHandleSomSom(t, tctxt->state, tr->reportId, som, end,
-                                      tctxt, in_anchored);
-            } else {
-                rv = roseHandleSomMatch(t, tctxt->state, tr->reportId, som, end,
-                                        tctxt, in_anchored);
-            }
-        } else {
-            if (tr->flags & ROSE_ROLE_FLAG_SOM_REPORT) {
-                /* do som management */
-                rv = roseHandleSom(t, tctxt->state, tr->reportId, end, tctxt,
-                                  in_anchored);
-            } else if (tr->flags & ROSE_ROLE_FLAG_CHAIN_REPORT) {
-                rv = roseCatchUpAndHandleChainMatch(t, tctxt->state,
-                                                    tr->reportId, end, tctxt,
-                                                    in_anchored);
-            } else {
-                rv = roseHandleMatch(t, tctxt->state, tr->reportId, end, tctxt,
-                                     in_anchored);
-            }
-        }
-
-        if (rv != HWLM_CONTINUE_MATCHING) {
-            return HWLM_TERMINATE_MATCHING;
-        }
-    }
-
-    roseSetRole(t, tctxt->state, tctxt, tr);
-
-    *work_done = 1;
-
-    return HWLM_CONTINUE_MATCHING;
-}
-
-static really_inline
-hwlmcb_rv_t roseHandleRole(const struct RoseEngine *t,
-                           const struct RoseRole *tr, u64a end,
-                           struct RoseContext *tctxt, char in_anchored,
-                           int *work_done) {
-    DEBUG_PRINTF("hi role %zd (flags %08x)\n", tr - getRoleTable(t),
-                  tr->flags);
-    if (in_anchored && end > t->floatingMinLiteralMatchOffset) {
-        DEBUG_PRINTF("delay until playback, just do groups/depth now\n");
-        update_depth(tctxt, tr);
-        tctxt->groups |= tr->groups;
-        *work_done = 1;
-        return HWLM_CONTINUE_MATCHING;
-    }
-
-    if (!roseCheckRolePreconditions(t, tr, end, tctxt)) {
-        return HWLM_CONTINUE_MATCHING;
-    }
-
-    /* We now know the role has matched. We can now trigger things that need to
-     * be triggered and record things that need to be recorded.*/
-
-    return roseHandleRoleEffects(t, tr, end, tctxt, in_anchored, work_done);
-}
-
-static really_inline
-void roseSquashGroup(struct RoseContext *tctxt, const struct RoseLiteral *tl) {
-    assert(tl->squashesGroup);
-
-    // we should be squashing a single group
-    assert(popcount64(tl->groups) == 1);
-
-    DEBUG_PRINTF("apply squash mask 0x%016llx, groups 0x%016llx -> 0x%016llx\n",
-                 ~tl->groups, tctxt->groups, tctxt->groups & ~tl->groups);
-
-    tctxt->groups &= ~tl->groups;
-}
-
-// Run the sparse iterator for this literal and use that to discover which
-// roles to consider.
-/* Note: uses the stashed sparse iter state; cannot be called from
- * anybody else who is using it */
-/* Note: uses the handled role mmbit; cannot be called from
- * anybody else who is using it (nobody else should be) */
-/* non-root roles should not occur in any anchored context */
-static really_inline
-hwlmcb_rv_t roseWalkSparseIterator(const struct RoseEngine *t,
-                                   const struct RoseLiteral *tl, u64a end,
-                                   struct RoseContext *tctxt) {
-    /* assert(!tctxt->in_anchored); */
-    /* assert(!tctxt->in_anch_playback); */
-    const struct RoseRole *roleTable = getRoleTable(t);
-    const struct RosePred *predTable = getPredTable(t);
-    const struct RoseIterMapping *iterMapBase
-        = getByOffset(t, tl->iterMapOffset);
-    const struct mmbit_sparse_iter *it = getByOffset(t, tl->iterOffset);
-    assert(ISALIGNED(iterMapBase));
-    assert(ISALIGNED(it));
-
-    // Sparse iterator state was allocated earlier
-    struct mmbit_sparse_state *s = tctxtToScratch(tctxt)->sparse_iter_state;
-    struct fatbit *handled_roles = tctxtToScratch(tctxt)->handled_roles;
-
-    const u32 numStates = t->rolesWithStateCount;
-
-    void *role_state = getRoleState(tctxt->state);
-    u32 idx = 0;
-    int work_done = 0; // set to 1 if we actually process any roles
-    u32 i = mmbit_sparse_iter_begin(role_state, numStates, &idx, it, s);
-
-    fatbit_clear(handled_roles);
-
-    for (; i != MMB_INVALID;
-           i = mmbit_sparse_iter_next(role_state, numStates, i, &idx, it, s)) {
-        DEBUG_PRINTF("pred state %u (iter idx=%u) is on\n", i, idx);
-        const struct RoseIterMapping *iterMap = iterMapBase + idx;
-        const struct RoseIterRole *roles = getByOffset(t, iterMap->offset);
-        assert(ISALIGNED(roles));
-
-        DEBUG_PRINTF("%u roles to consider\n", iterMap->count);
-        for (u32 j = 0; j != iterMap->count; j++) {
-            u32 role = roles[j].role;
-            assert(role < t->roleCount);
-            DEBUG_PRINTF("checking role %u, pred %u:\n", role, roles[j].pred);
-            const struct RoseRole *tr = roleTable + role;
-
-            if (fatbit_isset(handled_roles, t->roleCount, role)) {
-                DEBUG_PRINTF("role %u already handled by the walk, skip\n",
-                             role);
-                continue;
-            }
-
-            // Special case: if this role is a trivial case (pred type simple)
-            // we don't need to check any history and we already know the pred
-            // role is on.
-            if (tr->flags & ROSE_ROLE_PRED_SIMPLE) {
-                DEBUG_PRINTF("pred type is simple, no need for further"
-                             " checks\n");
-            } else {
-                assert(roles[j].pred < t->predCount);
-                const struct RosePred *tp = predTable + roles[j].pred;
-                if (!roseCheckPredHistory(tp, end)) {
-                    continue;
-                }
-            }
-
-            /* mark role as handled so we don't touch it again in this walk */
-            fatbit_set(handled_roles, t->roleCount, role);
-
-            hwlmcb_rv_t rv = roseHandleRole(t, tr, end, tctxt,
-                                            0 /* in_anchored */, &work_done);
-            if (rv == HWLM_TERMINATE_MATCHING) {
-                return HWLM_TERMINATE_MATCHING;
-            }
-        }
-    }
-
-    // If we've actually handled any roles, we might need to apply this
-    // literal's squash mask to our groups as well.
-    if (work_done && tl->squashesGroup) {
-        roseSquashGroup(tctxt, tl);
-    }
-
-    return HWLM_CONTINUE_MATCHING;
-}
-
-// Check that the predecessor bounds are satisfied for a root role with special
-// requirements (anchored, or unanchored but with preceding dots).
-static rose_inline
-char roseCheckRootBounds(const struct RoseEngine *t, const struct RoseRole *tr,
-                         u64a end) {
-    assert(tr->predOffset != ROSE_OFFSET_INVALID);
-    const struct RosePred *tp = getPredTable(t) + tr->predOffset;
-    assert(tp->role == MO_INVALID_IDX);
-
-    // Check history. We only use a subset of our history types for root or
-    // anchored root roles.
-    assert(tp->historyCheck == ROSE_ROLE_HISTORY_NONE ||
-           tp->historyCheck == ROSE_ROLE_HISTORY_ANCH);
-
-    return roseCheckPredHistory(tp, end);
-}
-
-// Walk the set of root roles (roles with depth 1) associated with this literal
-// and set them on.
-static really_inline
-char roseWalkRootRoles_i(const struct RoseEngine *t,
-                         const struct RoseLiteral *tl, u64a end,
-                         struct RoseContext *tctxt, char in_anchored) {
-    /* main entry point ensures that there is at least two root roles */
-    int work_done = 0;
-
-    assert(tl->rootRoleOffset + tl->rootRoleCount <= t->rootRoleCount);
-    assert(tl->rootRoleCount > 1);
-
-    const u32 *rootRole = getRootRoleTable(t) + tl->rootRoleOffset;
-    const u32 *rootRoleEnd = rootRole + tl->rootRoleCount;
-    for (; rootRole < rootRoleEnd; rootRole++) {
-        u32 role_offset = *rootRole;
-        const struct RoseRole *tr = getRoleByOffset(t, role_offset);
-
-        if (!in_anchored && (tr->flags & ROSE_ROLE_PRED_ROOT)
-            && !roseCheckRootBounds(t, tr, end)) {
-            continue;
-        }
-
-        if (roseHandleRole(t, tr, end, tctxt, in_anchored, &work_done)
-            == HWLM_TERMINATE_MATCHING) {
-            return 0;
-        }
-    };
-
-    // If we've actually handled any roles, we might need to apply this
-    // literal's squash mask to our groups as well.
-    if (work_done && tl->squashesGroup) {
-        roseSquashGroup(tctxt, tl);
-    }
-
-    return 1;
-}
-
-static never_inline
-char roseWalkRootRoles_A(const struct RoseEngine *t,
-                         const struct RoseLiteral *tl, u64a end,
-                         struct RoseContext *tctxt) {
-    return roseWalkRootRoles_i(t, tl, end, tctxt, 1);
-}
-
-static never_inline
-char roseWalkRootRoles_N(const struct RoseEngine *t,
-                         const struct RoseLiteral *tl, u64a end,
-                         struct RoseContext *tctxt) {
-    return roseWalkRootRoles_i(t, tl, end, tctxt, 0);
-}
-
-static really_inline
-char roseWalkRootRoles_i1(const struct RoseEngine *t,
-                          const struct RoseLiteral *tl, u64a end,
-                          struct RoseContext *tctxt, char in_anchored) {
-    /* main entry point ensures that there is exactly one root role */
-    int work_done = 0;
-    u32 role_offset = tl->rootRoleOffset;
-    const struct RoseRole *tr = getRoleByOffset(t, role_offset);
-
-    if (!in_anchored && (tr->flags & ROSE_ROLE_PRED_ROOT)
-        && !roseCheckRootBounds(t, tr, end)) {
-        return 1;
-    }
-
-    hwlmcb_rv_t rv = roseHandleRole(t, tr, end, tctxt, in_anchored, &work_done);
-    if (rv == HWLM_TERMINATE_MATCHING) {
-        return 0;
-    }
-
-    // If we've actually handled any roles, we might need to apply this
-    // literal's squash mask to our groups as well.
-    if (work_done && tl->squashesGroup) {
-        roseSquashGroup(tctxt, tl);
-    }
-
-    return 1;
-}
-
-static never_inline
-char roseWalkRootRoles_A1(const struct RoseEngine *t,
-                          const struct RoseLiteral *tl, u64a end,
-                          struct RoseContext *tctxt) {
-    return roseWalkRootRoles_i1(t, tl, end, tctxt, 1);
-}
-
-static never_inline
-char roseWalkRootRoles_N1(const struct RoseEngine *t,
-                          const struct RoseLiteral *tl, u64a end,
-                          struct RoseContext *tctxt) {
-    return roseWalkRootRoles_i1(t, tl, end, tctxt, 0);
-}
-
-
-static really_inline
-char roseWalkRootRoles(const struct RoseEngine *t,
-                       const struct RoseLiteral *tl, u64a end,
-                       struct RoseContext *tctxt, char in_anchored,
-                       char in_anch_playback) {
-    DEBUG_PRINTF("literal has %u root roles\n", tl->rootRoleCount);
-
-    assert(!in_anch_playback || tl->rootRoleCount);
-    if (!in_anch_playback && !tl->rootRoleCount) {
-        return 1;
-    }
-
-    if (in_anchored) {
-        if (tl->rootRoleCount == 1) {
-            return roseWalkRootRoles_A1(t, tl, end, tctxt);
-        } else {
-            return roseWalkRootRoles_A(t, tl, end, tctxt);
-        }
-    } else {
-        if (tl->rootRoleCount == 1) {
-            return roseWalkRootRoles_N1(t, tl, end, tctxt);
-        } else {
-            return roseWalkRootRoles_N(t, tl, end, tctxt);
-        }
-    }
-}
-
-void roseSidecarCallback(UNUSED u64a offset, u32 side_id, void *context) {
-    struct RoseContext *tctxt = context;
-    const struct RoseEngine *t = tctxt->t;
-
-    DEBUG_PRINTF("SIDE MATCH side_id=%u offset=[%llu, %llu]\n", side_id,
-                 offset, offset + 1);
-    assert(side_id < t->sideCount);
-
-    const struct RoseSide *side = &getSideEntryTable(t)[side_id];
-    roseSquashStates(t, side, tctxt);
-
-    DEBUG_PRINTF("done with sc\n");
-}
-
-/* handles catchup, som, cb, etc */
-static really_inline
-hwlmcb_rv_t roseHandleReport(const struct RoseEngine *t, u8 *state,
-                             struct RoseContext *tctxt, ReportID id, u64a offset,
-                             char in_anchored) {
-    const struct internal_report *ri = getInternalReport(t, id);
-
-    if (ri) {
-        // Mildly cheesy performance hack: if this report is already exhausted,
-        // we can quash the match here.
-        if (ri->ekey != INVALID_EKEY) {
-            const struct hs_scratch *scratch = tctxtToScratch(tctxt);
-            if (isExhausted(scratch->core_info.exhaustionVector, ri->ekey)) {
-                DEBUG_PRINTF("eating exhausted match (report %u, ekey %u)\n",
-                             ri->onmatch, ri->ekey);
-                return HWLM_CONTINUE_MATCHING;
-            }
-        }
-
-        if (isInternalSomReport(ri)) {
-            return roseHandleSom(t, state, id, offset, tctxt, in_anchored);
-        } else if (ri->type == INTERNAL_ROSE_CHAIN) {
-            return roseCatchUpAndHandleChainMatch(t, state, id, offset, tctxt,
-                                                  in_anchored);
-        }
-    }
-    return roseHandleMatch(t, state, id, offset, tctxt, in_anchored);
-}
-
-static really_inline
-hwlmcb_rv_t roseHandleAnchoredDirectReport(const struct RoseEngine *t,
-                                           u8 *state, struct RoseContext *tctxt,
-                                           u64a real_end, ReportID report) {
-    DEBUG_PRINTF("direct report %u, real_end=%llu\n", report, real_end);
-
-    if (real_end > t->maxSafeAnchoredDROffset) {
-        DEBUG_PRINTF("match in overlapped anchored region --> stash\n");
-        recordAnchoredMatch(tctxt, report, real_end);
-        return HWLM_CONTINUE_MATCHING;
-    }
-
-    return roseHandleReport(t, state, tctxt, report, real_end,
-                            1 /* in anchored */);
-}
-
 int roseAnchoredCallback(u64a end, u32 id, void *ctx) {
-    struct RoseContext *tctxt = ctx;
-    const struct RoseEngine *t = tctxt->t;
-    u8 *state = tctxt->state;
-    struct core_info *ci = &tctxtToScratch(tctxt)->core_info;
+    struct hs_scratch *scratch = ctx;
+    struct RoseContext *tctxt = &scratch->tctxt;
+    struct core_info *ci = &scratch->core_info;
+    const struct RoseEngine *t = ci->rose;
 
     u64a real_end = ci->buf_offset + end; // index after last byte
 
     DEBUG_PRINTF("MATCH id=%u offsets=[???,%llu]\n", id, real_end);
-    DEBUG_PRINTF("STATE depth=%u, groups=0x%016llx\n", tctxt->depth,
-                 tctxt->groups);
+    DEBUG_PRINTF("STATE groups=0x%016llx\n", tctxt->groups);
 
-    if (can_stop_matching(tctxtToScratch(tctxt))) {
+    if (can_stop_matching(scratch)) {
         DEBUG_PRINTF("received a match when we're already dead!\n");
         return MO_HALT_MATCHING;
     }
 
-    hwlmcb_rv_t rv = HWLM_CONTINUE_MATCHING;
+    const size_t match_len = 0;
 
     /* delayed literals need to be delivered before real literals; however
      * delayed literals only come from the floating table so if we are going
@@ -1636,69 +245,30 @@ int roseAnchoredCallback(u64a end, u32 id, void *ctx) {
     /* no history checks from anchored region and we are before the flush
      * boundary */
 
-    if (isLiteralMDR(id)) {
-        // Multi-direct report, list of reports indexed by the ID.
-        u32 mdr_offset = id & ~LITERAL_MDR_FLAG;
-        const ReportID *report =
-            (const ReportID *)((const char *)t + t->multidirectOffset) +
-            mdr_offset;
-        for (; *report != MO_INVALID_IDX; report++) {
-            rv = roseHandleAnchoredDirectReport(t, state, tctxt, real_end,
-                                                *report);
-            if (rv == HWLM_TERMINATE_MATCHING) {
-                return MO_HALT_MATCHING;
-            }
-        }
-        return MO_CONTINUE_MATCHING;
-    } else if (isLiteralDR(id)) {
-        // Single direct report.
-        ReportID report = literalToReport(id);
-        rv = roseHandleAnchoredDirectReport(t, state, tctxt, real_end, report);
-        if (rv == HWLM_TERMINATE_MATCHING) {
-            return MO_HALT_MATCHING;
-        }
-        return MO_CONTINUE_MATCHING;
-    }
-
-    assert(id < t->literalCount);
-    const struct RoseLiteral *tl = &getLiteralTable(t)[id];
-    assert(tl->rootRoleCount > 0);
-    assert(!tl->delay_mask);
-
-    DEBUG_PRINTF("literal id=%u, minDepth=%u, groups=0x%016llx, "
-                 "rootRoleCount=%u\n",
-                 id, tl->minDepth, tl->groups, tl->rootRoleCount);
-
     if (real_end <= t->floatingMinLiteralMatchOffset) {
-        roseFlushLastByteHistory(t, state, real_end, tctxt);
+        roseFlushLastByteHistory(t, scratch, real_end);
         tctxt->lastEndOffset = real_end;
     }
 
-    if (tl->requires_side
-        && real_end <= t->floatingMinLiteralMatchOffset) {
-        /* Catch up the sidecar to the literal location. This means that all
-         * squashing events are delivered before any 'side involved' literal
-         * matches at a given location. */
-
-        catchup_sidecar(tctxt, real_end);
-    }
-
-    /* anchored literals are root only */
-    if (!roseWalkRootRoles(t, tl, real_end, tctxt, 1, 0)) {
-        rv = HWLM_TERMINATE_MATCHING;
-    }
-
-    DEBUG_PRINTF("DONE depth=%u, groups=0x%016llx\n", tctxt->depth,
-                 tctxt->groups);
-
-    if (rv == HWLM_TERMINATE_MATCHING) {
-        assert(can_stop_matching(tctxtToScratch(tctxt)));
+    const u32 *programs = getByOffset(t, t->litProgramOffset);
+    assert(id < t->literalCount);
+    const u64a som = 0;
+    const char in_anchored = 1;
+    const char in_catchup = 0;
+    const char from_mpv = 0;
+    const char skip_mpv_catchup = 0;
+    if (roseRunProgram(t, scratch, programs[id], som, real_end, match_len,
+                       in_anchored, in_catchup, from_mpv,
+                       skip_mpv_catchup) == HWLM_TERMINATE_MATCHING) {
+        assert(can_stop_matching(scratch));
         DEBUG_PRINTF("caller requested termination\n");
         return MO_HALT_MATCHING;
     }
 
+    DEBUG_PRINTF("DONE groups=0x%016llx\n", tctxt->groups);
+
     if (real_end > t->floatingMinLiteralMatchOffset) {
-        recordAnchoredLiteralMatch(tctxt, id, real_end);
+        recordAnchoredLiteralMatch(t, scratch, id, real_end);
     }
 
     return MO_CONTINUE_MATCHING;
@@ -1707,148 +277,51 @@ int roseAnchoredCallback(u64a end, u32 id, void *ctx) {
 // Rose match-processing workhorse
 /* assumes not in_anchored */
 static really_inline
-hwlmcb_rv_t roseProcessMatch_i(const struct RoseEngine *t, u64a end, u32 id,
-                               struct RoseContext *tctxt, char do_group_check,
-                               char in_delay_play, char in_anch_playback) {
-    /* assert(!tctxt->in_anchored); */
-    u8 *state = tctxt->state;
-
+hwlmcb_rv_t roseProcessMatch(const struct RoseEngine *t,
+                             struct hs_scratch *scratch, u64a end,
+                             size_t match_len, u32 id) {
     DEBUG_PRINTF("id=%u\n", id);
-
-    if (!in_anch_playback && !in_delay_play) {
-        if (isLiteralMDR(id)) {
-            // Multi-direct report, list of reports indexed by the ID.
-            u32 mdr_offset = id & ~LITERAL_MDR_FLAG;
-            const ReportID *report =
-                (const ReportID *)((const char *)t + t->multidirectOffset) +
-                mdr_offset;
-            for (; *report != MO_INVALID_IDX; report++) {
-                DEBUG_PRINTF("handle multi-direct report %u\n", *report);
-                hwlmcb_rv_t rv = roseHandleReport(t, state, tctxt, *report, end,
-                                                  0 /* in anchored */);
-                if (rv == HWLM_TERMINATE_MATCHING) {
-                    return HWLM_TERMINATE_MATCHING;
-                }
-            }
-            return HWLM_CONTINUE_MATCHING;
-        } else if (isLiteralDR(id)) {
-            // Single direct report.
-            ReportID report = literalToReport(id);
-            DEBUG_PRINTF("handle direct report %u\n", report);
-            return roseHandleReport(t, state, tctxt, report, end,
-                                    0 /* in anchored */);
-        }
-    }
-
+    const u32 *programs = getByOffset(t, t->litProgramOffset);
     assert(id < t->literalCount);
-    const struct RoseLiteral *tl = &getLiteralTable(t)[id];
-    DEBUG_PRINTF("lit id=%u, minDepth=%u, groups=0x%016llx, rootRoleCount=%u\n",
-                 id, tl->minDepth, tl->groups, tl->rootRoleCount);
-
-    if (do_group_check && !(tl->groups & tctxt->groups)) {
-        DEBUG_PRINTF("IGNORE: none of this literal's groups are set.\n");
-        return HWLM_CONTINUE_MATCHING;
-    }
-
-    assert(!in_delay_play || !tl->delay_mask);
-    if (!in_delay_play) {
-        pushDelayedMatches(tl, end, tctxt);
-    }
-
-    if (end < t->floatingMinLiteralMatchOffset) {
-        DEBUG_PRINTF("too soon\n");
-        assert(!in_delay_play); /* should not have been enqueued */
-        /* continuing on may result in pushing global time back */
-        return HWLM_CONTINUE_MATCHING;
-    }
-
-    // If the current literal requires sidecar support, run to current
-    // location.
-    if (tl->requires_side) {
-        /* Catch up the sidecar to the literal location. This means that all
-         * squashing events are delivered before any 'side involved' literal
-         * matches at a given location. */
-
-        if (tl->rootRoleCount || tl->minDepth <= tctxt->depth) {
-            catchup_sidecar(tctxt, end);
-        }
-    }
-
-    if (tl->minDepth > tctxt->depth) {
-        DEBUG_PRINTF("IGNORE: minDepth=%u > %u\n", tl->minDepth, tctxt->depth);
-        goto root_roles;
-    }
-
-    /* the depth checks will normally prevent roles without a spare iterator
-     * from reaching here (root roles) (and only root roles should be seen
-     * during anch play back). */
-    assert(tl->iterOffset == ROSE_OFFSET_INVALID || !in_anch_playback);
-    if (tl->iterOffset != ROSE_OFFSET_INVALID && !in_anch_playback) {
-        hwlmcb_rv_t rv = roseWalkSparseIterator(t, tl, end, tctxt);
-
-        if (rv == HWLM_TERMINATE_MATCHING) {
-            return HWLM_TERMINATE_MATCHING;
-        }
-    }
-
-root_roles:
-    // Process "root roles", i.e. depth 1 roles for this literal
-    if (!roseWalkRootRoles(t, tl, end, tctxt, 0 /* in_anchored */,
-                           in_anch_playback)) {
-        return HWLM_TERMINATE_MATCHING;
-    }
-
-    return HWLM_CONTINUE_MATCHING;
-}
-
-
-static never_inline
-hwlmcb_rv_t roseProcessDelayedMatch(const struct RoseEngine *t, u64a end, u32 id,
-                                    struct RoseContext *tctxt) {
-    return roseProcessMatch_i(t, end, id, tctxt, 1, 1, 0);
-}
-
-static never_inline
-hwlmcb_rv_t roseProcessDelayedAnchoredMatch(const struct RoseEngine *t, u64a end,
-                                            u32 id, struct RoseContext *tctxt) {
-    return roseProcessMatch_i(t, end, id, tctxt, 0, 0, 1);
-}
-
-static really_inline
-hwlmcb_rv_t roseProcessMainMatch(const struct RoseEngine *t, u64a end, u32 id,
-                                 struct RoseContext *tctxt) {
-    return roseProcessMatch_i(t, end, id, tctxt, 1, 0, 0);
+    const u64a som = 0;
+    const char in_anchored = 0;
+    const char in_catchup = 0;
+    const char from_mpv = 0;
+    const char skip_mpv_catchup = 0;
+    return roseRunProgram(t, scratch, programs[id], som, end, match_len,
+                          in_anchored, in_catchup, from_mpv, skip_mpv_catchup);
 }
 
 static rose_inline
-hwlmcb_rv_t playDelaySlot(struct RoseContext *tctxt, const u8 *delaySlotBase,
-                          size_t delaySlotSize, u32 vicIndex, u64a offset) {
+hwlmcb_rv_t playDelaySlot(const struct RoseEngine *t,
+                          struct hs_scratch *scratch,
+                          struct fatbit **delaySlots, u32 vicIndex,
+                          u64a offset) {
     /* assert(!tctxt->in_anchored); */
     assert(vicIndex < DELAY_SLOT_COUNT);
-    const u8 *vicSlot = delaySlotBase + delaySlotSize * vicIndex;
-    u32 delay_count = tctxt->t->delay_count;
+    const struct fatbit *vicSlot = delaySlots[vicIndex];
+    u32 delay_count = t->delay_count;
 
-    if (offset < tctxt->t->floatingMinLiteralMatchOffset) {
+    if (offset < t->floatingMinLiteralMatchOffset) {
         DEBUG_PRINTF("too soon\n");
         return HWLM_CONTINUE_MATCHING;
     }
 
-    roseFlushLastByteHistory(tctxt->t, tctxt->state, offset, tctxt);
+    struct RoseContext *tctxt = &scratch->tctxt;
+    roseFlushLastByteHistory(t, scratch, offset);
     tctxt->lastEndOffset = offset;
 
-    for (u32 it = mmbit_iterate(vicSlot, delay_count, MMB_INVALID);
-         it != MMB_INVALID; it = mmbit_iterate(vicSlot, delay_count, it)) {
-        u32 literal_id = tctxt->t->delay_base_id + it;
+    for (u32 it = fatbit_iterate(vicSlot, delay_count, MMB_INVALID);
+         it != MMB_INVALID; it = fatbit_iterate(vicSlot, delay_count, it)) {
+        u32 literal_id = t->delay_base_id + it;
 
         UNUSED rose_group old_groups = tctxt->groups;
 
         DEBUG_PRINTF("DELAYED MATCH id=%u offset=%llu\n", literal_id, offset);
-        hwlmcb_rv_t rv = roseProcessDelayedMatch(tctxt->t, offset, literal_id,
-                                                 tctxt);
-        DEBUG_PRINTF("DONE depth=%u, groups=0x%016llx\n", tctxt->depth,
-                     tctxt->groups);
+        hwlmcb_rv_t rv = roseProcessMatch(t, scratch, offset, 0, literal_id);
+        DEBUG_PRINTF("DONE groups=0x%016llx\n", tctxt->groups);
 
-        /* delayed literals can't safely set groups, squashing may from side.
+        /* delayed literals can't safely set groups.
          * However we may be setting groups that successors already have
          * worked out that we don't need to match the group */
         DEBUG_PRINTF("groups in %016llx out %016llx\n", old_groups,
@@ -1863,26 +336,27 @@ hwlmcb_rv_t playDelaySlot(struct RoseContext *tctxt, const u8 *delaySlotBase,
 }
 
 static really_inline
-hwlmcb_rv_t flushAnchoredLiteralAtLoc(struct RoseContext *tctxt, u32 curr_loc) {
-    u8 *curr_row = getAnchoredLiteralLog(tctxtToScratch(tctxt))[curr_loc - 1];
-    u32 region_width = tctxt->t->anchored_count;
+hwlmcb_rv_t flushAnchoredLiteralAtLoc(const struct RoseEngine *t,
+                                      struct hs_scratch *scratch,
+                                      u32 curr_loc) {
+    struct RoseContext *tctxt = &scratch->tctxt;
+    struct fatbit *curr_row = getAnchoredLiteralLog(scratch)[curr_loc - 1];
+    u32 region_width = t->anchored_count;
 
     DEBUG_PRINTF("report matches at curr loc\n");
-    for (u32 it = mmbit_iterate(curr_row, region_width, MMB_INVALID);
-         it != MMB_INVALID; it = mmbit_iterate(curr_row, region_width, it)) {
+    for (u32 it = fatbit_iterate(curr_row, region_width, MMB_INVALID);
+         it != MMB_INVALID; it = fatbit_iterate(curr_row, region_width, it)) {
         DEBUG_PRINTF("it = %u/%u\n", it, region_width);
-        u32 literal_id = tctxt->t->anchored_base_id + it;
+        u32 literal_id = t->anchored_base_id + it;
 
         rose_group old_groups = tctxt->groups;
         DEBUG_PRINTF("ANCH REPLAY MATCH id=%u offset=%u\n", literal_id,
                      curr_loc);
-        hwlmcb_rv_t rv = roseProcessDelayedAnchoredMatch(tctxt->t, curr_loc,
-                                                         literal_id, tctxt);
-        DEBUG_PRINTF("DONE depth=%u, groups=0x%016llx\n", tctxt->depth,
-                     tctxt->groups);
+        hwlmcb_rv_t rv = roseProcessMatch(t, scratch, curr_loc, 0, literal_id);
+        DEBUG_PRINTF("DONE groups=0x%016llx\n", tctxt->groups);
 
-        /* anchored literals can't safely set groups, squashing may from
-         * side. However we may be setting groups that successors already
+        /* anchored literals can't safely set groups.
+         * However we may be setting groups that successors already
          * have worked out that we don't need to match the group */
         DEBUG_PRINTF("groups in %016llx out %016llx\n", old_groups,
                      tctxt->groups);
@@ -1894,28 +368,28 @@ hwlmcb_rv_t flushAnchoredLiteralAtLoc(struct RoseContext *tctxt, u32 curr_loc) {
     }
 
     /* clear row; does not invalidate iteration */
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
     bf64_unset(&scratch->al_log_sum, curr_loc - 1);
 
     return HWLM_CONTINUE_MATCHING;
 }
 
 static really_inline
-u32 anchored_it_begin(struct RoseContext *tctxt) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
+u32 anchored_it_begin(struct hs_scratch *scratch) {
+    struct RoseContext *tctxt = &scratch->tctxt;
     if (tctxt->lastEndOffset >= scratch->anchored_literal_region_len) {
         return MMB_INVALID;
     }
     u32 begin = tctxt->lastEndOffset;
     begin--;
 
-    return bf64_iterate(tctxtToScratch(tctxt)->al_log_sum, begin);
+    return bf64_iterate(scratch->al_log_sum, begin);
 }
 
 static really_inline
-hwlmcb_rv_t flushAnchoredLiterals(struct RoseContext *tctxt,
+hwlmcb_rv_t flushAnchoredLiterals(const struct RoseEngine *t,
+                                  struct hs_scratch *scratch,
                                   u32 *anchored_it_param, u64a to_off) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
+    struct RoseContext *tctxt = &scratch->tctxt;
     u32 anchored_it = *anchored_it_param;
     /* catch up any remaining anchored matches */
     for (; anchored_it != MMB_INVALID && anchored_it < to_off;
@@ -1923,10 +397,10 @@ hwlmcb_rv_t flushAnchoredLiterals(struct RoseContext *tctxt,
         assert(anchored_it < scratch->anchored_literal_region_len);
         DEBUG_PRINTF("loc_it = %u\n", anchored_it);
         u32 curr_off = anchored_it + 1;
-        roseFlushLastByteHistory(tctxt->t, tctxt->state, curr_off, tctxt);
+        roseFlushLastByteHistory(t, scratch, curr_off);
         tctxt->lastEndOffset = curr_off;
 
-        if (flushAnchoredLiteralAtLoc(tctxt, curr_off)
+        if (flushAnchoredLiteralAtLoc(t, scratch, curr_off)
             == HWLM_TERMINATE_MATCHING) {
             return HWLM_TERMINATE_MATCHING;
         }
@@ -1937,24 +411,21 @@ hwlmcb_rv_t flushAnchoredLiterals(struct RoseContext *tctxt,
 }
 
 static really_inline
-hwlmcb_rv_t playVictims(struct RoseContext *tctxt, u32 *anchored_it,
-                        u64a lastEnd, u64a victimDelaySlots, u8 *delaySlotBase,
-                        size_t delaySlotSize) {
-    /* assert (!tctxt->in_anchored); */
-
+hwlmcb_rv_t playVictims(const struct RoseEngine *t, struct hs_scratch *scratch,
+                        u32 *anchored_it, u64a lastEnd, u64a victimDelaySlots,
+                        struct fatbit **delaySlots) {
     while (victimDelaySlots) {
         u32 vic = findAndClearLSB_64(&victimDelaySlots);
         DEBUG_PRINTF("vic = %u\n", vic);
         u64a vicOffset = vic + (lastEnd & ~(u64a)DELAY_MASK);
 
-        if (flushAnchoredLiterals(tctxt, anchored_it, vicOffset)
+        if (flushAnchoredLiterals(t, scratch, anchored_it, vicOffset)
             == HWLM_TERMINATE_MATCHING) {
             return HWLM_TERMINATE_MATCHING;
         }
 
-        if (playDelaySlot(tctxt, delaySlotBase, delaySlotSize,
-                          vic % DELAY_SLOT_COUNT, vicOffset)
-            == HWLM_TERMINATE_MATCHING) {
+        if (playDelaySlot(t, scratch, delaySlots, vic % DELAY_SLOT_COUNT,
+                          vicOffset) == HWLM_TERMINATE_MATCHING) {
             return HWLM_TERMINATE_MATCHING;
         }
     }
@@ -1963,15 +434,16 @@ hwlmcb_rv_t playVictims(struct RoseContext *tctxt, u32 *anchored_it,
 }
 
 /* call flushQueuedLiterals instead */
-hwlmcb_rv_t flushQueuedLiterals_i(struct RoseContext *tctxt, u64a currEnd) {
-    /* assert(!tctxt->in_anchored); */
+hwlmcb_rv_t flushQueuedLiterals_i(const struct RoseEngine *t,
+                                  struct hs_scratch *scratch, u64a currEnd) {
+    struct RoseContext *tctxt = &scratch->tctxt;
     u64a lastEnd = tctxt->delayLastEndOffset;
     DEBUG_PRINTF("flushing backed up matches @%llu up from %llu\n", currEnd,
                  lastEnd);
 
     assert(currEnd != lastEnd); /* checked in main entry point */
 
-    u32 anchored_it = anchored_it_begin(tctxt);
+    u32 anchored_it = anchored_it_begin(scratch);
 
     if (!tctxt->filledDelayedSlots) {
         DEBUG_PRINTF("no delayed, no flush\n");
@@ -1979,8 +451,7 @@ hwlmcb_rv_t flushQueuedLiterals_i(struct RoseContext *tctxt, u64a currEnd) {
     }
 
     {
-        u8 *delaySlotBase = getDelaySlots(tctxtToScratch(tctxt));
-        size_t delaySlotSize = tctxt->t->delay_slot_size;
+        struct fatbit **delaySlots = getDelaySlots(scratch);
 
         u32 lastIndex = lastEnd & DELAY_MASK;
         u32 currIndex = currEnd & DELAY_MASK;
@@ -2033,50 +504,45 @@ hwlmcb_rv_t flushQueuedLiterals_i(struct RoseContext *tctxt, u64a currEnd) {
                          second_half, victimDelaySlots, lastIndex);
         }
 
-        if (playVictims(tctxt, &anchored_it, lastEnd, victimDelaySlots,
-                        delaySlotBase, delaySlotSize)
-            == HWLM_TERMINATE_MATCHING) {
+        if (playVictims(t, scratch, &anchored_it, lastEnd, victimDelaySlots,
+                        delaySlots) == HWLM_TERMINATE_MATCHING) {
             return HWLM_TERMINATE_MATCHING;
         }
     }
 
 anchored_leftovers:;
-    hwlmcb_rv_t rv = flushAnchoredLiterals(tctxt, &anchored_it, currEnd);
+    hwlmcb_rv_t rv = flushAnchoredLiterals(t, scratch, &anchored_it, currEnd);
     tctxt->delayLastEndOffset = currEnd;
     return rv;
 }
 
 hwlmcb_rv_t roseCallback(size_t start, size_t end, u32 id, void *ctxt) {
-    struct RoseContext *tctx = ctxt;
+    struct hs_scratch *scratch = ctxt;
+    struct RoseContext *tctx = &scratch->tctxt;
+    const struct RoseEngine *t = scratch->core_info.rose;
+
     u64a real_end = end + tctx->lit_offset_adjust;
 
 #if defined(DEBUG)
-    struct core_info *ci = &tctxtToScratch(tctx)->core_info;
     DEBUG_PRINTF("MATCH id=%u offsets=[%llu,%llu]: ", id,
                  start + tctx->lit_offset_adjust, real_end);
-    printMatch(ci, start + tctx->lit_offset_adjust, real_end);
+    printMatch(&scratch->core_info, start + tctx->lit_offset_adjust, real_end);
     printf("\n");
 #endif
     DEBUG_PRINTF("last end %llu\n", tctx->lastEndOffset);
 
-    DEBUG_PRINTF("STATE depth=%u, groups=0x%016llx\n", tctx->depth,
-                 tctx->groups);
+    DEBUG_PRINTF("STATE groups=0x%016llx\n", tctx->groups);
 
-    if (can_stop_matching(tctxtToScratch(tctx))) {
+    if (can_stop_matching(scratch)) {
         DEBUG_PRINTF("received a match when we're already dead!\n");
         return HWLM_TERMINATE_MATCHING;
     }
 
-    if (id < tctx->t->nonbenefits_base_id
-        && !roseCheckLiteralBenefits(real_end, end - start + 1, id, tctx)) {
-        return tctx->groups;
-    }
-
-    hwlmcb_rv_t rv = flushQueuedLiterals(tctx, real_end);
+    hwlmcb_rv_t rv = flushQueuedLiterals(t, scratch, real_end);
     /* flushDelayed may have advanced tctx->lastEndOffset */
 
-    if (real_end >= tctx->t->floatingMinLiteralMatchOffset) {
-        roseFlushLastByteHistory(tctx->t, tctx->state, real_end, tctx);
+    if (real_end >= t->floatingMinLiteralMatchOffset) {
+        roseFlushLastByteHistory(t, scratch, real_end);
         tctx->lastEndOffset = real_end;
     }
 
@@ -2084,44 +550,123 @@ hwlmcb_rv_t roseCallback(size_t start, size_t end, u32 id, void *ctxt) {
         return HWLM_TERMINATE_MATCHING;
     }
 
-    rv = roseProcessMainMatch(tctx->t, real_end, id, tctx);
+    size_t match_len = end - start + 1;
+    rv = roseProcessMatch(t, scratch, real_end, match_len, id);
 
-    DEBUG_PRINTF("DONE depth=%hhu, groups=0x%016llx\n", tctx->depth,
-                 tctx->groups);
+    DEBUG_PRINTF("DONE groups=0x%016llx\n", tctx->groups);
 
     if (rv != HWLM_TERMINATE_MATCHING) {
         return tctx->groups;
     }
 
-    assert(can_stop_matching(tctxtToScratch(tctx)));
+    assert(can_stop_matching(scratch));
     DEBUG_PRINTF("user requested halt\n");
     return HWLM_TERMINATE_MATCHING;
 }
 
-// Specialised cut-down roseCallback for running ROSE_EVENT "literals", like the
-// EOD one.
-void roseRunEvent(size_t end, u32 id, struct RoseContext *tctxt) {
-    const struct RoseEngine *t = tctxt->t;
-    struct core_info *ci = &tctxtToScratch(tctxt)->core_info;
-    u64a real_end = ci->buf_offset - ci->hlen + end;
-
-    DEBUG_PRINTF("EVENT id=%u offset=%llu\n", id, real_end);
-
-    // Caller should guard against broken stream.
-    assert(!can_stop_matching(tctxtToScratch(tctxt)));
-
-    // Shouldn't be here if we're a real literal with benefits.
-    assert(id >= t->nonbenefits_base_id);
-
-    // At the moment, this path is only used for the EOD event.
-    assert(id == t->eodLiteralId);
-
-    // There should be no pending delayed literals.
-    assert(!tctxt->filledDelayedSlots);
-
-    // Note: we throw away the return value.
-    roseProcessMatch_i(t, real_end, id, tctxt, 0, 0, 0);
-
-    DEBUG_PRINTF("DONE depth=%hhu, groups=0x%016llx\n", tctxt->depth,
-                 tctxt->groups);
+/**
+ * \brief Match callback adaptor used for matches from pure-literal cases.
+ *
+ * Literal match IDs in this path run limited Rose programs that do not use
+ * Rose state (which is not initialised in the pure-literal path). They can
+ * still, for example, check lookarounds or literal masks.
+ */
+hwlmcb_rv_t rosePureLiteralCallback(size_t start, size_t end, u32 id,
+                                    void *context) {
+    DEBUG_PRINTF("start=%zu, end=%zu, id=%u\n", start, end, id);
+    struct hs_scratch *scratch = context;
+    struct core_info *ci = &scratch->core_info;
+    const u64a real_end = (u64a)end + ci->buf_offset + 1;
+    const u64a som = 0;
+    const size_t match_len = end - start + 1;
+    const struct RoseEngine *rose = ci->rose;
+    const u32 *programs = getByOffset(rose, rose->litProgramOffset);
+    assert(id < rose->literalCount);
+    const char in_anchored = 0;
+    const char in_catchup = 0;
+    const char from_mpv = 0;
+    const char skip_mpv_catchup = 0;
+    return roseRunProgram(rose, scratch, programs[id], som, real_end, match_len,
+                          in_anchored, in_catchup, from_mpv, skip_mpv_catchup);
+}
+
+/**
+ * \brief Execute a boundary report program.
+ *
+ * Returns MO_HALT_MATCHING if the stream is exhausted or the user has
+ * instructed us to halt, or MO_CONTINUE_MATCHING otherwise.
+ */
+int roseRunBoundaryProgram(const struct RoseEngine *rose, u32 program,
+                           u64a stream_offset, struct hs_scratch *scratch) {
+    DEBUG_PRINTF("running boundary program at offset %u\n", program);
+
+    if (can_stop_matching(scratch)) {
+        DEBUG_PRINTF("can stop matching\n");
+        return MO_HALT_MATCHING;
+    }
+
+    if (rose->hasSom && scratch->deduper.current_report_offset == ~0ULL) {
+        /* we cannot delay the initialization of the som deduper logs any longer
+         * as we are reporting matches. This is done explicitly as we are
+         * shortcutting the som handling in the vacuous repeats as we know they
+         * all come from non-som patterns. */
+        fatbit_clear(scratch->deduper.som_log[0]);
+        fatbit_clear(scratch->deduper.som_log[1]);
+        scratch->deduper.som_log_dirty = 0;
+    }
+
+    // Keep assertions in program report path happy. At offset zero, there can
+    // have been no earlier reports. At EOD, all earlier reports should have
+    // been handled and we will have been caught up to the stream offset by the
+    // time we are running boundary report programs.
+    scratch->tctxt.minMatchOffset = stream_offset;
+
+    const u64a som = 0;
+    const size_t match_len = 0;
+    const char in_anchored = 0;
+    const char in_catchup = 0;
+    const char from_mpv = 0;
+    const char skip_mpv_catchup = 0;
+    hwlmcb_rv_t rv =
+        roseRunProgram(rose, scratch, program, som, stream_offset, match_len,
+                       in_anchored, in_catchup, from_mpv, skip_mpv_catchup);
+    if (rv == HWLM_TERMINATE_MATCHING) {
+        return MO_HALT_MATCHING;
+    }
+
+    return MO_CONTINUE_MATCHING;
+}
+
+static really_inline
+int roseReportAdaptor_i(u64a som, u64a offset, ReportID id, void *context) {
+    struct hs_scratch *scratch = context;
+    assert(scratch && scratch->magic == SCRATCH_MAGIC);
+
+    const struct RoseEngine *rose = scratch->core_info.rose;
+
+    // Our match ID is the program offset.
+    const u32 program = id;
+    const size_t match_len = 0; // Unused in this path.
+    const char in_anchored = 0;
+    const char in_catchup = 0;
+    const char from_mpv = 0;
+    const char skip_mpv_catchup = 1;
+    hwlmcb_rv_t rv =
+        roseRunProgram(rose, scratch, program, som, offset, match_len,
+                       in_anchored, in_catchup, from_mpv, skip_mpv_catchup);
+    if (rv == HWLM_TERMINATE_MATCHING) {
+        return MO_HALT_MATCHING;
+    }
+
+    return can_stop_matching(scratch) ? MO_HALT_MATCHING : MO_CONTINUE_MATCHING;
+}
+
+int roseReportAdaptor(u64a offset, ReportID id, void *context) {
+    DEBUG_PRINTF("offset=%llu, id=%u\n", offset, id);
+    return roseReportAdaptor_i(0, offset, id, context);
+}
+
+int roseReportSomAdaptor(u64a som, u64a offset, ReportID id, void *context) {
+    DEBUG_PRINTF("som=%llu, offset=%llu, id=%u\n", som, offset, id);
+    return roseReportAdaptor_i(som, offset, id, context);
 }
diff --git a/src/rose/match.h b/src/rose/match.h
index 19365f01..cee32fc2 100644
--- a/src/rose/match.h
+++ b/src/rose/match.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -40,13 +40,12 @@
 #include "nfa/nfa_api_util.h"
 #include "som/som_runtime.h"
 #include "util/bitutils.h"
-#include "util/internal_report.h"
+#include "util/fatbit.h"
 #include "util/multibit.h"
 
 /* Callbacks, defined in catchup.c */
 
 int roseNfaAdaptor(u64a offset, ReportID id, void *context);
-int roseNfaAdaptorNoInternal(u64a offset, ReportID id, void *context);
 int roseNfaSomAdaptor(u64a from_offset, u64a offset, ReportID id, void *context);
 
 /* Callbacks, defined in match.c */
@@ -55,55 +54,32 @@ hwlmcb_rv_t roseCallback(size_t start, size_t end, u32 id, void *ctx);
 hwlmcb_rv_t roseDelayRebuildCallback(size_t start, size_t end, u32 id,
                                      void *ctx);
 int roseAnchoredCallback(u64a end, u32 id, void *ctx);
-void roseRunEvent(size_t end, u32 id, struct RoseContext *tctxt);
 
 /* Common code, used all over Rose runtime */
 
-static rose_inline
-void resetAnchoredLog(const struct RoseEngine *t, struct hs_scratch *scratch) {
-    u8 **anchoredRows = getAnchoredLog(scratch);
-    u32 region_width = t->anchoredMatches;
-    struct RoseContext *tctxt = &scratch->tctxt;
-
-    tctxt->curr_anchored_loc = bf64_iterate(scratch->am_log_sum, MMB_INVALID);
-    if (tctxt->curr_anchored_loc != MMB_INVALID) {
-        assert(tctxt->curr_anchored_loc < scratch->anchored_region_len);
-        u8 *curr_row = anchoredRows[tctxt->curr_anchored_loc];
-        tctxt->curr_row_offset = mmbit_iterate(curr_row, region_width,
-                                               MMB_INVALID);
-        assert(tctxt->curr_row_offset != MMB_INVALID);
-    }
-    DEBUG_PRINTF("AL reset --> %u, %u\n", tctxt->curr_anchored_loc,
-                 tctxt->curr_row_offset);
-}
-
-hwlmcb_rv_t roseHandleChainMatch(const struct RoseEngine *t, ReportID r,
-                                 u64a end, struct RoseContext *tctxt,
-                                 char in_anchored, char in_catchup);
+hwlmcb_rv_t roseHandleChainMatch(const struct RoseEngine *t,
+                                 struct hs_scratch *scratch, u32 event,
+                                 u64a top_squash_distance, u64a end,
+                                 char in_catchup);
 
 static really_inline
 void initQueue(struct mq *q, u32 qi, const struct RoseEngine *t,
-               struct RoseContext *tctxt) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
+               struct hs_scratch *scratch) {
     const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
     assert(scratch->fullState);
     q->nfa = getNfaByInfo(t, info);
     q->end = 0;
     q->cur = 0;
     q->state = scratch->fullState + info->fullStateOffset;
-    q->streamState = (char *)tctxt->state + info->stateOffset;
+    q->streamState = scratch->core_info.state + info->stateOffset;
     q->offset = scratch->core_info.buf_offset;
     q->buffer = scratch->core_info.buf;
     q->length = scratch->core_info.len;
     q->history = scratch->core_info.hbuf;
     q->hlength = scratch->core_info.hlen;
-    if (info->only_external) {
-        q->cb = roseNfaAdaptorNoInternal;
-    } else {
-        q->cb = roseNfaAdaptor;
-    }
+    q->cb = roseNfaAdaptor;
     q->som_cb = roseNfaSomAdaptor;
-    q->context = tctxt;
+    q->context = scratch;
     q->report_current = 0;
 
     DEBUG_PRINTF("qi=%u, offset=%llu, fullState=%u, streamState=%u, "
@@ -114,8 +90,7 @@ void initQueue(struct mq *q, u32 qi, const struct RoseEngine *t,
 static really_inline
 void initRoseQueue(const struct RoseEngine *t, u32 qi,
                    const struct LeftNfaInfo *left,
-                   struct RoseContext *tctxt) {
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
+                   struct hs_scratch *scratch) {
     struct mq *q = scratch->queues + qi;
     const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
     q->nfa = getNfaByInfo(t, info);
@@ -130,7 +105,7 @@ void initRoseQueue(const struct RoseEngine *t, u32 qi,
     if (left->transient) {
         q->streamState = (char *)scratch->tstate + info->stateOffset;
     } else {
-        q->streamState = (char *)tctxt->state + info->stateOffset;
+        q->streamState = scratch->core_info.state + info->stateOffset;
     }
 
     q->offset = scratch->core_info.buf_offset;
@@ -162,7 +137,7 @@ void loadStreamState(const struct NFA *nfa, struct mq *q, s64a loc) {
 }
 
 static really_inline
-void storeRoseDelay(const struct RoseEngine *t, u8 *state,
+void storeRoseDelay(const struct RoseEngine *t, char *state,
                     const struct LeftNfaInfo *left, u32 loc) {
     u32 di = left->lagIndex;
     if (di == ROSE_OFFSET_INVALID) {
@@ -177,7 +152,7 @@ void storeRoseDelay(const struct RoseEngine *t, u8 *state,
 }
 
 static really_inline
-void setAsZombie(const struct RoseEngine *t, u8 *state,
+void setAsZombie(const struct RoseEngine *t, char *state,
                  const struct LeftNfaInfo *left) {
     u32 di = left->lagIndex;
     assert(di != ROSE_OFFSET_INVALID);
@@ -192,7 +167,7 @@ void setAsZombie(const struct RoseEngine *t, u8 *state,
 /* loadRoseDelay MUST NOT be called on the first stream write as it is only
  * initialized for running nfas on stream boundaries */
 static really_inline
-u32 loadRoseDelay(const struct RoseEngine *t, const u8 *state,
+u32 loadRoseDelay(const struct RoseEngine *t, const char *state,
                   const struct LeftNfaInfo *left) {
     u32 di = left->lagIndex;
     if (di == ROSE_OFFSET_INVALID) {
@@ -206,7 +181,7 @@ u32 loadRoseDelay(const struct RoseEngine *t, const u8 *state,
 }
 
 static really_inline
-char isZombie(const struct RoseEngine *t, const u8 *state,
+char isZombie(const struct RoseEngine *t, const char *state,
               const struct LeftNfaInfo *left) {
     u32 di = left->lagIndex;
     assert(di != ROSE_OFFSET_INVALID);
@@ -219,40 +194,46 @@ char isZombie(const struct RoseEngine *t, const u8 *state,
     return leftfixDelay[di] == OWB_ZOMBIE_ALWAYS_YES;
 }
 
-hwlmcb_rv_t flushQueuedLiterals_i(struct RoseContext *tctxt, u64a end);
+hwlmcb_rv_t flushQueuedLiterals_i(const struct RoseEngine *t,
+                                  struct hs_scratch *scratch, u64a end);
 
 static really_inline
-hwlmcb_rv_t flushQueuedLiterals(struct RoseContext *tctxt, u64a end) {
+hwlmcb_rv_t flushQueuedLiterals(const struct RoseEngine *t,
+                                struct hs_scratch *scratch, u64a end) {
+    struct RoseContext *tctxt = &scratch->tctxt;
+
     if (tctxt->delayLastEndOffset == end) {
         DEBUG_PRINTF("no progress, no flush\n");
         return HWLM_CONTINUE_MATCHING;
     }
 
-    if (!tctxt->filledDelayedSlots && !tctxtToScratch(tctxt)->al_log_sum) {
+    if (!tctxt->filledDelayedSlots && !scratch->al_log_sum) {
         tctxt->delayLastEndOffset = end;
         return HWLM_CONTINUE_MATCHING;
     }
 
-    return flushQueuedLiterals_i(tctxt, end);
+    return flushQueuedLiterals_i(t, scratch, end);
 }
 
 static really_inline
-hwlmcb_rv_t cleanUpDelayed(size_t length, u64a offset, struct RoseContext *tctxt,
-                           u8 *status) {
-    if (can_stop_matching(tctxtToScratch(tctxt))) {
+hwlmcb_rv_t cleanUpDelayed(const struct RoseEngine *t,
+                           struct hs_scratch *scratch, size_t length,
+                           u64a offset) {
+    if (can_stop_matching(scratch)) {
         return HWLM_TERMINATE_MATCHING;
     }
 
-    if (flushQueuedLiterals(tctxt, length + offset)
+    if (flushQueuedLiterals(t, scratch, length + offset)
         == HWLM_TERMINATE_MATCHING) {
         return HWLM_TERMINATE_MATCHING;
     }
 
+    struct RoseContext *tctxt = &scratch->tctxt;
     if (tctxt->filledDelayedSlots) {
         DEBUG_PRINTF("dirty\n");
-        *status |= DELAY_FLOAT_DIRTY;
+        scratch->core_info.status |= STATUS_DELAY_DIRTY;
     } else {
-        *status &= ~DELAY_FLOAT_DIRTY;
+        scratch->core_info.status &= ~STATUS_DELAY_DIRTY;
     }
 
     tctxt->filledDelayedSlots = 0;
@@ -261,48 +242,14 @@ hwlmcb_rv_t cleanUpDelayed(size_t length, u64a offset, struct RoseContext *tctxt
     return HWLM_CONTINUE_MATCHING;
 }
 
-static really_inline
-void update_depth(struct RoseContext *tctxt, const struct RoseRole *tr) {
-    u8 d = MAX(tctxt->depth, tr->depth + 1);
-    assert(d >= tctxt->depth);
-    DEBUG_PRINTF("depth now %hhu was %hhu\n", d, tctxt->depth);
-    tctxt->depth = d;
-}
-
-static really_inline
-int roseCheckHistoryAnch(const struct RosePred *tp, u64a end) {
-    DEBUG_PRINTF("end %llu min %u max %u\n", end, tp->minBound, tp->maxBound);
-    if (tp->maxBound == ROSE_BOUND_INF) {
-        return end >= tp->minBound;
-    } else {
-        return end >= tp->minBound && end <= tp->maxBound;
-    }
-}
-
-// Check that a predecessor's history requirements are satisfied.
-static really_inline
-int roseCheckPredHistory(const struct RosePred *tp, u64a end) {
-    DEBUG_PRINTF("pred type %u\n", tp->historyCheck);
-
-    if (tp->historyCheck == ROSE_ROLE_HISTORY_ANCH) {
-        return roseCheckHistoryAnch(tp, end);
-    }
-
-    assert(tp->historyCheck == ROSE_ROLE_HISTORY_NONE ||
-           tp->historyCheck == ROSE_ROLE_HISTORY_LAST_BYTE);
-    return 1;
-}
-
-/* Note: uses the stashed sparse iter state; cannot be called from
- * anybody else who is using it */
 static rose_inline
-void roseFlushLastByteHistory(const struct RoseEngine *t, u8 *state,
-                              u64a currEnd, struct RoseContext *tctxt) {
+void roseFlushLastByteHistory(const struct RoseEngine *t,
+                              struct hs_scratch *scratch, u64a currEnd) {
     if (!t->lastByteHistoryIterOffset) {
         return;
     }
 
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
+    struct RoseContext *tctxt = &scratch->tctxt;
     struct core_info *ci = &scratch->core_info;
 
     /* currEnd is last byte of string + 1 */
@@ -314,13 +261,37 @@ void roseFlushLastByteHistory(const struct RoseEngine *t, u8 *state,
 
     DEBUG_PRINTF("flushing\n");
 
-    const struct mmbit_sparse_iter *it
-        = (const void *)((const char *)t + t->lastByteHistoryIterOffset);
-    const u32 numStates = t->rolesWithStateCount;
-    void *role_state = getRoleState(state);
+    const struct mmbit_sparse_iter *it =
+        getByOffset(t, t->lastByteHistoryIterOffset);
+    assert(ISALIGNED(it));
 
-    mmbit_sparse_iter_unset(role_state, numStates, it,
-                            scratch->sparse_iter_state);
+    const u32 numStates = t->rolesWithStateCount;
+    void *role_state = getRoleState(scratch->core_info.state);
+
+    struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES];
+
+    mmbit_sparse_iter_unset(role_state, numStates, it, si_state);
+}
+
+static rose_inline
+int roseHasInFlightMatches(const struct RoseEngine *t, char *state,
+                           const struct hs_scratch *scratch) {
+    if (scratch->al_log_sum) {
+        DEBUG_PRINTF("anchored literals in log\n");
+        return 1;
+    }
+
+    if (scratch->tctxt.filledDelayedSlots) {
+        DEBUG_PRINTF("delayed literal\n");
+        return 1;
+    }
+
+    if (mmbit_any(getRoleState(state), t->rolesWithStateCount)) {
+        DEBUG_PRINTF("role state is set\n");
+        return 1;
+    }
+
+    return 0;
 }
 
 #endif
diff --git a/src/rose/program_runtime.h b/src/rose/program_runtime.h
new file mode 100644
index 00000000..78397070
--- /dev/null
+++ b/src/rose/program_runtime.h
@@ -0,0 +1,1319 @@
+/*
+ * Copyright (c) 2015-2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef PROGRAM_RUNTIME_H
+#define PROGRAM_RUNTIME_H
+
+#include "catchup.h"
+#include "counting_miracle.h"
+#include "infix.h"
+#include "match.h"
+#include "miracle.h"
+#include "report.h"
+#include "rose.h"
+#include "rose_internal.h"
+#include "rose_program.h"
+#include "rose_types.h"
+#include "runtime.h"
+#include "scratch.h"
+#include "ue2common.h"
+#include "util/compare.h"
+#include "util/fatbit.h"
+#include "util/multibit.h"
+
+static rose_inline
+int roseCheckBenefits(const struct core_info *ci, u64a end, u32 mask_rewind,
+                      const u8 *and_mask, const u8 *exp_mask) {
+    const u8 *data;
+
+    // If the check works over part of the history and part of the buffer, we
+    // create a temporary copy of the data in here so it's contiguous.
+    u8 temp[MAX_MASK2_WIDTH];
+
+    s64a buffer_offset = (s64a)end - ci->buf_offset;
+    DEBUG_PRINTF("rel offset %lld\n", buffer_offset);
+    if (buffer_offset >= mask_rewind) {
+        data = ci->buf + buffer_offset - mask_rewind;
+        DEBUG_PRINTF("all in one case data=%p buf=%p rewind=%u\n", data,
+                     ci->buf, mask_rewind);
+    } else if (buffer_offset <= 0) {
+        data = ci->hbuf + ci->hlen + buffer_offset - mask_rewind;
+        DEBUG_PRINTF("all in one case data=%p buf=%p rewind=%u\n", data,
+                     ci->buf, mask_rewind);
+    } else {
+        u32 shortfall = mask_rewind - buffer_offset;
+        DEBUG_PRINTF("shortfall of %u, rewind %u hlen %zu\n", shortfall,
+                     mask_rewind, ci->hlen);
+        data = temp;
+        memcpy(temp, ci->hbuf + ci->hlen - shortfall, shortfall);
+        memcpy(temp + shortfall, ci->buf, mask_rewind - shortfall);
+    }
+
+#ifdef DEBUG
+    DEBUG_PRINTF("DATA: ");
+    for (u32 i = 0; i < mask_rewind; i++) {
+        printf("%c", ourisprint(data[i]) ? data[i] : '?');
+    }
+    printf(" (len=%u)\n", mask_rewind);
+#endif
+
+    u32 len = mask_rewind;
+    while (len >= sizeof(u64a)) {
+        u64a a = unaligned_load_u64a(data);
+        a &= *(const u64a *)and_mask;
+        if (a != *(const u64a *)exp_mask) {
+            DEBUG_PRINTF("argh %016llx %016llx\n", a, *(const u64a *)exp_mask);
+            return 0;
+        }
+        data += sizeof(u64a);
+        and_mask += sizeof(u64a);
+        exp_mask += sizeof(u64a);
+        len -= sizeof(u64a);
+    }
+
+    while (len) {
+        u8 a = *data;
+        a &= *and_mask;
+        if (a != *exp_mask) {
+            DEBUG_PRINTF("argh d%02hhx =%02hhx am%02hhx  em%02hhx\n", a,
+                          *data, *and_mask, *exp_mask);
+            return 0;
+        }
+        data++;
+        and_mask++;
+        exp_mask++;
+        len--;
+    }
+
+    return 1;
+}
+
+static rose_inline
+void rosePushDelayedMatch(const struct RoseEngine *t,
+                          struct hs_scratch *scratch, u32 delay,
+                          u32 delay_index, u64a offset) {
+    assert(delay);
+
+    const u32 src_slot_index = delay;
+    u32 slot_index = (src_slot_index + offset) & DELAY_MASK;
+
+    struct RoseContext *tctxt = &scratch->tctxt;
+    if (offset + src_slot_index <= tctxt->delayLastEndOffset) {
+        DEBUG_PRINTF("skip too late\n");
+        return;
+    }
+
+    const u32 delay_count = t->delay_count;
+    struct fatbit **delaySlots = getDelaySlots(scratch);
+    struct fatbit *slot = delaySlots[slot_index];
+
+    DEBUG_PRINTF("pushing tab %u into slot %u\n", delay_index, slot_index);
+    if (!(tctxt->filledDelayedSlots & (1U << slot_index))) {
+        tctxt->filledDelayedSlots |= 1U << slot_index;
+        fatbit_clear(slot);
+    }
+
+    fatbit_set(slot, delay_count, delay_index);
+}
+
+static rose_inline
+char roseLeftfixCheckMiracles(const struct RoseEngine *t,
+                              const struct LeftNfaInfo *left,
+                              struct core_info *ci, struct mq *q, u64a end,
+                              const char is_infix) {
+    if (!is_infix && left->transient) {
+        // Miracles won't help us with transient leftfix engines; they only
+        // scan for a limited time anyway.
+        return 1;
+    }
+
+    if (!left->stopTable) {
+        return 1;
+    }
+
+    DEBUG_PRINTF("looking for miracle on queue %u\n", q->nfa->queueIndex);
+
+    const s64a begin_loc = q_cur_loc(q);
+    const s64a end_loc = end - ci->buf_offset;
+
+    s64a miracle_loc;
+    if (roseMiracleOccurs(t, left, ci, begin_loc, end_loc, &miracle_loc)) {
+        goto found_miracle;
+    }
+
+    if (roseCountingMiracleOccurs(t, left, ci, begin_loc, end_loc,
+                                  &miracle_loc)) {
+        goto found_miracle;
+    }
+
+    return 1;
+
+found_miracle:
+    DEBUG_PRINTF("miracle at %lld\n", miracle_loc);
+    assert(miracle_loc >= begin_loc);
+
+    // If we're a prefix, then a miracle effectively results in us needing to
+    // re-init our state and start fresh.
+    if (!is_infix) {
+        if (miracle_loc != begin_loc) {
+            DEBUG_PRINTF("re-init prefix state\n");
+            q->cur = q->end = 0;
+            pushQueueAt(q, 0, MQE_START, miracle_loc);
+            pushQueueAt(q, 1, MQE_TOP, miracle_loc);
+            nfaQueueInitState(q->nfa, q);
+        }
+        return 1;
+    }
+
+    // Otherwise, we're an infix. Remove tops before the miracle from the queue
+    // and re-init at that location.
+
+    q_skip_forward_to(q, miracle_loc);
+
+    if (q_last_type(q) == MQE_START) {
+        DEBUG_PRINTF("miracle caused infix to die\n");
+        return 0;
+    }
+
+    DEBUG_PRINTF("re-init infix state\n");
+    assert(q->items[q->cur].type == MQE_START);
+    q->items[q->cur].location = miracle_loc;
+    nfaQueueInitState(q->nfa, q);
+
+    return 1;
+}
+
+static rose_inline
+hwlmcb_rv_t roseHaltIfExhausted(const struct RoseEngine *t,
+                                struct hs_scratch *scratch) {
+    struct core_info *ci = &scratch->core_info;
+    if (isAllExhausted(t, ci->exhaustionVector)) {
+        ci->status |= STATUS_EXHAUSTED;
+        scratch->tctxt.groups = 0;
+        DEBUG_PRINTF("all exhausted, termination requested\n");
+        return HWLM_TERMINATE_MATCHING;
+    }
+
+    return HWLM_CONTINUE_MATCHING;
+}
+
+static really_inline
+hwlmcb_rv_t ensureQueueFlushed_i(const struct RoseEngine *t,
+                                 struct hs_scratch *scratch, u32 qi, s64a loc,
+                                 char is_mpv, char in_catchup) {
+    struct RoseContext *tctxt = &scratch->tctxt;
+    u8 *aa = getActiveLeafArray(t, scratch->core_info.state);
+    struct fatbit *activeQueues = scratch->aqa;
+    u32 aaCount = t->activeArrayCount;
+    u32 qCount = t->queueCount;
+
+    struct mq *q = &scratch->queues[qi];
+    DEBUG_PRINTF("qcl %lld, loc: %lld, min (non mpv) match offset: %llu\n",
+                 q_cur_loc(q), loc, tctxt->minNonMpvMatchOffset);
+    if (q_cur_loc(q) == loc) {
+        /* too many tops enqueued at the one spot; need to flatten this queue.
+         * We can use the full catchups as it will short circuit as we are
+         * already at this location. It also saves waking everybody up */
+        pushQueueNoMerge(q, MQE_END, loc);
+        nfaQueueExec(q->nfa, q, loc);
+        q->cur = q->end = 0;
+        pushQueueAt(q, 0, MQE_START, loc);
+    } else if (!in_catchup) {
+        if (is_mpv) {
+            tctxt->next_mpv_offset = 0; /* force us to catch the mpv */
+            if (loc + scratch->core_info.buf_offset
+                <= tctxt->minNonMpvMatchOffset) {
+                DEBUG_PRINTF("flushing chained\n");
+                if (roseCatchUpMPV(t, loc, scratch) ==
+                    HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+                goto done_queue_empty;
+            }
+        }
+
+        if (roseCatchUpTo(t, scratch, loc + scratch->core_info.buf_offset) ==
+            HWLM_TERMINATE_MATCHING) {
+            return HWLM_TERMINATE_MATCHING;
+        }
+    } else {
+        /* we must be a chained nfa */
+        assert(is_mpv);
+        DEBUG_PRINTF("flushing chained\n");
+        tctxt->next_mpv_offset = 0; /* force us to catch the mpv */
+        if (roseCatchUpMPV(t, loc, scratch) == HWLM_TERMINATE_MATCHING) {
+            return HWLM_TERMINATE_MATCHING;
+        }
+    }
+done_queue_empty:
+    if (!mmbit_set(aa, aaCount, qi)) {
+        initQueue(q, qi, t, scratch);
+        nfaQueueInitState(q->nfa, q);
+        pushQueueAt(q, 0, MQE_START, loc);
+        fatbit_set(activeQueues, qCount, qi);
+    }
+
+    assert(!isQueueFull(q));
+
+    return roseHaltIfExhausted(t, scratch);
+}
+
+static rose_inline
+hwlmcb_rv_t ensureQueueFlushed(const struct RoseEngine *t,
+                               struct hs_scratch *scratch, u32 qi, s64a loc) {
+    return ensureQueueFlushed_i(t, scratch, qi, loc, 0, 0);
+}
+
+static rose_inline
+hwlmcb_rv_t roseTriggerSuffix(const struct RoseEngine *t,
+                              struct hs_scratch *scratch, u32 qi, u32 top,
+                              u64a som, u64a end) {
+    DEBUG_PRINTF("suffix qi=%u, top event=%u\n", qi, top);
+
+    struct core_info *ci = &scratch->core_info;
+    u8 *aa = getActiveLeafArray(t, ci->state);
+    const u32 aaCount = t->activeArrayCount;
+    const u32 qCount = t->queueCount;
+    struct mq *q = &scratch->queues[qi];
+    const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
+    const struct NFA *nfa = getNfaByInfo(t, info);
+
+    s64a loc = (s64a)end - ci->buf_offset;
+    assert(loc <= (s64a)ci->len && loc >= -(s64a)ci->hlen);
+
+    if (!mmbit_set(aa, aaCount, qi)) {
+        initQueue(q, qi, t, scratch);
+        nfaQueueInitState(nfa, q);
+        pushQueueAt(q, 0, MQE_START, loc);
+        fatbit_set(scratch->aqa, qCount, qi);
+    } else if (info->no_retrigger) {
+        DEBUG_PRINTF("yawn\n");
+        /* nfa only needs one top; we can go home now */
+        return HWLM_CONTINUE_MATCHING;
+    } else if (!fatbit_set(scratch->aqa, qCount, qi)) {
+        initQueue(q, qi, t, scratch);
+        loadStreamState(nfa, q, 0);
+        pushQueueAt(q, 0, MQE_START, 0);
+    } else if (isQueueFull(q)) {
+        DEBUG_PRINTF("queue %u full -> catching up nfas\n", qi);
+        if (info->eod) {
+            /* can catch up suffix independently no pq */
+            q->context = NULL;
+            pushQueueNoMerge(q, MQE_END, loc);
+            nfaQueueExecRose(q->nfa, q, MO_INVALID_IDX);
+            q->cur = q->end = 0;
+            pushQueueAt(q, 0, MQE_START, loc);
+        } else if (ensureQueueFlushed(t, scratch, qi, loc)
+            == HWLM_TERMINATE_MATCHING) {
+            return HWLM_TERMINATE_MATCHING;
+        }
+    }
+
+    assert(top == MQE_TOP || (top >= MQE_TOP_FIRST && top < MQE_INVALID));
+    pushQueueSom(q, top, loc, som);
+
+    if (q_cur_loc(q) == (s64a)ci->len && !info->eod) {
+        /* we may not run the nfa; need to ensure state is fine  */
+        DEBUG_PRINTF("empty run\n");
+        pushQueueNoMerge(q, MQE_END, loc);
+        char alive = nfaQueueExec(nfa, q, loc);
+        if (alive) {
+            q->cur = q->end = 0;
+            pushQueueAt(q, 0, MQE_START, loc);
+        } else {
+            mmbit_unset(aa, aaCount, qi);
+            fatbit_unset(scratch->aqa, qCount, qi);
+        }
+    }
+
+    return HWLM_CONTINUE_MATCHING;
+}
+
+static really_inline
+char roseTestLeftfix(const struct RoseEngine *t, struct hs_scratch *scratch,
+                     u32 qi, u32 leftfixLag, ReportID leftfixReport, u64a end,
+                     const char is_infix) {
+    struct core_info *ci = &scratch->core_info;
+
+    u32 ri = queueToLeftIndex(t, qi);
+    const struct LeftNfaInfo *left = getLeftTable(t) + ri;
+
+    DEBUG_PRINTF("testing %s %s %u/%u with lag %u (maxLag=%u)\n",
+                 (left->transient ? "transient" : "active"),
+                 (is_infix ? "infix" : "prefix"),
+                 ri, qi, leftfixLag, left->maxLag);
+
+    assert(leftfixLag <= left->maxLag);
+    assert(left->infix == is_infix);
+    assert(!is_infix || !left->transient); // Only prefixes can be transient.
+
+    struct mq *q = scratch->queues + qi;
+    char *state = scratch->core_info.state;
+    u8 *activeLeftArray = getActiveLeftArray(t, state);
+    u32 qCount = t->queueCount;
+    u32 arCount = t->activeLeftCount;
+
+    if (!mmbit_isset(activeLeftArray, arCount, ri)) {
+        DEBUG_PRINTF("engine is dead nothing to see here\n");
+        return 0;
+    }
+
+    if (unlikely(end < leftfixLag)) {
+        assert(0); /* lag is the literal length */
+        return 0;
+    }
+
+    if (nfaSupportsZombie(getNfaByQueue(t, qi)) && ci->buf_offset
+        && !fatbit_isset(scratch->aqa, qCount, qi)
+        && isZombie(t, state, left)) {
+        DEBUG_PRINTF("zombie\n");
+        return 1;
+    }
+
+    if (!fatbit_set(scratch->aqa, qCount, qi)) {
+        DEBUG_PRINTF("initing q %u\n", qi);
+        initRoseQueue(t, qi, left, scratch);
+        if (ci->buf_offset) { // there have been writes before us!
+            s32 sp;
+            if (!is_infix && left->transient) {
+                sp = -(s32)ci->hlen;
+            } else {
+                sp = -(s32)loadRoseDelay(t, state, left);
+            }
+
+            /* transient nfas are always started fresh -> state not maintained
+             * at stream boundary */
+
+            pushQueueAt(q, 0, MQE_START, sp);
+            if (is_infix || (ci->buf_offset + sp > 0 && !left->transient)) {
+                loadStreamState(q->nfa, q, sp);
+            } else {
+                pushQueueAt(q, 1, MQE_TOP, sp);
+                nfaQueueInitState(q->nfa, q);
+            }
+        } else { // first write ever
+            pushQueueAt(q, 0, MQE_START, 0);
+            pushQueueAt(q, 1, MQE_TOP, 0);
+            nfaQueueInitState(q->nfa, q);
+        }
+    }
+
+    s64a loc = (s64a)end - ci->buf_offset - leftfixLag;
+    assert(loc >= q_cur_loc(q));
+    assert(leftfixReport != MO_INVALID_IDX);
+
+    if (!is_infix && left->transient) {
+        s64a start_loc = loc - left->transient;
+        if (q_cur_loc(q) < start_loc) {
+            q->cur = q->end = 0;
+            pushQueueAt(q, 0, MQE_START, start_loc);
+            pushQueueAt(q, 1, MQE_TOP, start_loc);
+            nfaQueueInitState(q->nfa, q);
+        }
+    }
+
+    if (q_cur_loc(q) < loc || q_last_type(q) != MQE_START) {
+        if (is_infix) {
+            if (infixTooOld(q, loc)) {
+                DEBUG_PRINTF("infix %u died of old age\n", ri);
+                goto nfa_dead;
+            }
+
+            reduceInfixQueue(q, loc, left->maxQueueLen, q->nfa->maxWidth);
+        }
+
+        if (!roseLeftfixCheckMiracles(t, left, ci, q, end, is_infix)) {
+            DEBUG_PRINTF("leftfix %u died due to miracle\n", ri);
+            goto nfa_dead;
+        }
+
+#ifdef DEBUG
+        debugQueue(q);
+#endif
+
+        pushQueueNoMerge(q, MQE_END, loc);
+
+        char rv = nfaQueueExecRose(q->nfa, q, leftfixReport);
+        if (!rv) { /* nfa is dead */
+            DEBUG_PRINTF("leftfix %u died while trying to catch up\n", ri);
+            goto nfa_dead;
+        }
+
+        // Queue must have next start loc before we call nfaInAcceptState.
+        q->cur = q->end = 0;
+        pushQueueAt(q, 0, MQE_START, loc);
+
+        DEBUG_PRINTF("checking for report %u\n", leftfixReport);
+        DEBUG_PRINTF("leftfix done %hhd\n", (signed char)rv);
+        return rv == MO_MATCHES_PENDING;
+    } else {
+        DEBUG_PRINTF("checking for report %u\n", leftfixReport);
+        char rv = nfaInAcceptState(q->nfa, leftfixReport, q);
+        DEBUG_PRINTF("leftfix done %hhd\n", (signed char)rv);
+        return rv;
+    }
+
+nfa_dead:
+    mmbit_unset(activeLeftArray, arCount, ri);
+    scratch->tctxt.groups &= left->squash_mask;
+    return 0;
+}
+
+static rose_inline
+char roseTestPrefix(const struct RoseEngine *t, struct hs_scratch *scratch,
+                    u32 qi, u32 leftfixLag, ReportID leftfixReport, u64a end) {
+    return roseTestLeftfix(t, scratch, qi, leftfixLag, leftfixReport, end, 0);
+}
+
+static rose_inline
+char roseTestInfix(const struct RoseEngine *t, struct hs_scratch *scratch,
+                   u32 qi, u32 leftfixLag, ReportID leftfixReport, u64a end) {
+    return roseTestLeftfix(t, scratch, qi, leftfixLag, leftfixReport, end, 1);
+}
+
+static rose_inline
+void roseTriggerInfix(const struct RoseEngine *t, struct hs_scratch *scratch,
+                      u64a start, u64a end, u32 qi, u32 topEvent, u8 cancel) {
+    struct core_info *ci = &scratch->core_info;
+    s64a loc = (s64a)end - ci->buf_offset;
+
+    u32 ri = queueToLeftIndex(t, qi);
+    assert(topEvent < MQE_INVALID);
+
+    const struct LeftNfaInfo *left = getLeftInfoByQueue(t, qi);
+    assert(!left->transient);
+
+    DEBUG_PRINTF("rose %u (qi=%u) event %u\n", ri, qi, topEvent);
+
+    struct mq *q = scratch->queues + qi;
+    const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
+
+    char *state = ci->state;
+    u8 *activeLeftArray = getActiveLeftArray(t, state);
+    const u32 arCount = t->activeLeftCount;
+    char alive = mmbit_set(activeLeftArray, arCount, ri);
+
+    if (alive && info->no_retrigger) {
+        DEBUG_PRINTF("yawn\n");
+        return;
+    }
+
+    struct fatbit *aqa = scratch->aqa;
+    const u32 qCount = t->queueCount;
+
+    if (alive && nfaSupportsZombie(getNfaByInfo(t, info)) && ci->buf_offset &&
+        !fatbit_isset(aqa, qCount, qi) && isZombie(t, state, left)) {
+        DEBUG_PRINTF("yawn - zombie\n");
+        return;
+    }
+
+    if (cancel) {
+        DEBUG_PRINTF("dominating top: (re)init\n");
+        fatbit_set(aqa, qCount, qi);
+        initRoseQueue(t, qi, left, scratch);
+        pushQueueAt(q, 0, MQE_START, loc);
+        nfaQueueInitState(q->nfa, q);
+    } else if (!fatbit_set(aqa, qCount, qi)) {
+        DEBUG_PRINTF("initing %u\n", qi);
+        initRoseQueue(t, qi, left, scratch);
+        if (alive) {
+            s32 sp = -(s32)loadRoseDelay(t, state, left);
+            pushQueueAt(q, 0, MQE_START, sp);
+            loadStreamState(q->nfa, q, sp);
+        } else {
+            pushQueueAt(q, 0, MQE_START, loc);
+            nfaQueueInitState(q->nfa, q);
+        }
+    } else if (!alive) {
+        q->cur = q->end = 0;
+        pushQueueAt(q, 0, MQE_START, loc);
+        nfaQueueInitState(q->nfa, q);
+    } else if (isQueueFull(q)) {
+        reduceInfixQueue(q, loc, left->maxQueueLen, q->nfa->maxWidth);
+
+        if (isQueueFull(q)) {
+            /* still full - reduceInfixQueue did nothing */
+            DEBUG_PRINTF("queue %u full (%u items) -> catching up nfa\n", qi,
+                         q->end - q->cur);
+            pushQueueNoMerge(q, MQE_END, loc);
+            nfaQueueExecRose(q->nfa, q, MO_INVALID_IDX);
+
+            q->cur = q->end = 0;
+            pushQueueAt(q, 0, MQE_START, loc);
+        }
+    }
+
+    pushQueueSom(q, topEvent, loc, start);
+}
+
+static rose_inline
+hwlmcb_rv_t roseReport(const struct RoseEngine *t, struct hs_scratch *scratch,
+                       u64a end, ReportID onmatch, s32 offset_adjust,
+                       u32 ekey) {
+    assert(!t->needsCatchup || end == scratch->tctxt.minMatchOffset);
+    DEBUG_PRINTF("firing callback onmatch=%u, end=%llu\n", onmatch, end);
+    updateLastMatchOffset(&scratch->tctxt, end);
+
+    int cb_rv = roseDeliverReport(end, onmatch, offset_adjust, scratch, ekey);
+    if (cb_rv == MO_HALT_MATCHING) {
+        DEBUG_PRINTF("termination requested\n");
+        return HWLM_TERMINATE_MATCHING;
+    }
+
+    if (ekey == INVALID_EKEY || cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
+        return HWLM_CONTINUE_MATCHING;
+    }
+
+    return roseHaltIfExhausted(t, scratch);
+}
+
+/* catches up engines enough to ensure any earlier mpv triggers are enqueued
+ * and then adds the trigger to the mpv queue. Must not be called during catch
+ * up */
+static rose_inline
+hwlmcb_rv_t roseCatchUpAndHandleChainMatch(const struct RoseEngine *t,
+                                           struct hs_scratch *scratch,
+                                           u32 event, u64a top_squash_distance,
+                                           u64a end, const char in_catchup) {
+    if (!in_catchup &&
+        roseCatchUpMpvFeeders(t, scratch, end) == HWLM_TERMINATE_MATCHING) {
+        return HWLM_TERMINATE_MATCHING;
+    }
+    return roseHandleChainMatch(t, scratch, event, top_squash_distance, end,
+                                in_catchup);
+}
+
+static rose_inline
+void roseHandleSom(UNUSED const struct RoseEngine *t,
+                   struct hs_scratch *scratch, const struct som_operation *sr,
+                   u64a end) {
+    DEBUG_PRINTF("end=%llu, minMatchOffset=%llu\n", end,
+                 scratch->tctxt.minMatchOffset);
+
+    assert(!t->needsCatchup || end == scratch->tctxt.minMatchOffset);
+    updateLastMatchOffset(&scratch->tctxt, end);
+    handleSomInternal(scratch, sr, end);
+}
+
+static rose_inline
+hwlmcb_rv_t roseReportSom(const struct RoseEngine *t,
+                          struct hs_scratch *scratch, u64a start, u64a end,
+                          ReportID onmatch, s32 offset_adjust, u32 ekey) {
+    assert(!t->needsCatchup || end == scratch->tctxt.minMatchOffset);
+    DEBUG_PRINTF("firing som callback onmatch=%u, start=%llu, end=%llu\n",
+                 onmatch, start, end);
+    updateLastMatchOffset(&scratch->tctxt, end);
+
+    int cb_rv = roseDeliverSomReport(start, end, onmatch, offset_adjust,
+                                     scratch, ekey);
+    if (cb_rv == MO_HALT_MATCHING) {
+        DEBUG_PRINTF("termination requested\n");
+        return HWLM_TERMINATE_MATCHING;
+    }
+
+    if (ekey == INVALID_EKEY || cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
+        return HWLM_CONTINUE_MATCHING;
+    }
+
+    return roseHaltIfExhausted(t, scratch);
+}
+
+static rose_inline
+void roseHandleSomSom(UNUSED const struct RoseEngine *t,
+                      struct hs_scratch *scratch,
+                      const struct som_operation *sr, u64a start, u64a end) {
+    DEBUG_PRINTF("start=%llu, end=%llu, minMatchOffset=%llu\n", start, end,
+                 scratch->tctxt.minMatchOffset);
+
+    assert(!t->needsCatchup || end == scratch->tctxt.minMatchOffset);
+    updateLastMatchOffset(&scratch->tctxt, end);
+    setSomFromSomAware(scratch, sr, start, end);
+}
+
+static really_inline
+int reachHasBit(const u8 *reach, u8 c) {
+    return !!(reach[c / 8U] & (u8)1U << (c % 8U));
+}
+
+/**
+ * \brief Scan around a literal, checking that that "lookaround" reach masks
+ * are satisfied.
+ */
+static rose_inline
+int roseCheckLookaround(const struct RoseEngine *t,
+                        const struct hs_scratch *scratch, u32 lookaroundIndex,
+                        u32 lookaroundCount, u64a end) {
+    assert(lookaroundIndex != MO_INVALID_IDX);
+    assert(lookaroundCount > 0);
+
+    const struct core_info *ci = &scratch->core_info;
+    DEBUG_PRINTF("end=%llu, buf_offset=%llu, buf_end=%llu\n", end,
+                 ci->buf_offset, ci->buf_offset + ci->len);
+
+    const u8 *base = (const u8 *)t;
+    const s8 *look_base = (const s8 *)(base + t->lookaroundTableOffset);
+    const s8 *look = look_base + lookaroundIndex;
+    const s8 *look_end = look + lookaroundCount;
+    assert(look < look_end);
+
+    const u8 *reach_base = base + t->lookaroundReachOffset;
+    const u8 *reach = reach_base + lookaroundIndex * REACH_BITVECTOR_LEN;
+
+    // The following code assumes that the lookaround structures are ordered by
+    // increasing offset.
+
+    const s64a base_offset = end - ci->buf_offset;
+    DEBUG_PRINTF("base_offset=%lld\n", base_offset);
+    DEBUG_PRINTF("first look has offset %d\n", *look);
+
+    // If our first check tells us we need to look at an offset before the
+    // start of the stream, this role cannot match.
+    if (unlikely(*look < 0 && (u64a)(0 - *look) > end)) {
+        DEBUG_PRINTF("too early, fail\n");
+        return 0;
+    }
+
+    // Skip over offsets that are before the history buffer.
+    do {
+        s64a offset = base_offset + *look;
+        if (offset >= -(s64a)ci->hlen) {
+            goto in_history;
+        }
+        DEBUG_PRINTF("look=%d before history\n", *look);
+        look++;
+        reach += REACH_BITVECTOR_LEN;
+    } while (look < look_end);
+
+    // History buffer.
+    DEBUG_PRINTF("scan history (%zu looks left)\n", look_end - look);
+    for (; look < look_end; ++look, reach += REACH_BITVECTOR_LEN) {
+    in_history:
+        ;
+        s64a offset = base_offset + *look;
+        DEBUG_PRINTF("reach=%p, rel offset=%lld\n", reach, offset);
+
+        if (offset >= 0) {
+            DEBUG_PRINTF("in buffer\n");
+            goto in_buffer;
+        }
+
+        assert(offset >= -(s64a)ci->hlen && offset < 0);
+        u8 c = ci->hbuf[ci->hlen + offset];
+        if (!reachHasBit(reach, c)) {
+            DEBUG_PRINTF("char 0x%02x failed reach check\n", c);
+            return 0;
+        }
+    }
+    // Current buffer.
+    DEBUG_PRINTF("scan buffer (%zu looks left)\n", look_end - look);
+    for (; look < look_end; ++look, reach += REACH_BITVECTOR_LEN) {
+    in_buffer:
+        ;
+        s64a offset = base_offset + *look;
+        DEBUG_PRINTF("reach=%p, rel offset=%lld\n", reach, offset);
+
+        if (offset >= (s64a)ci->len) {
+            DEBUG_PRINTF("in the future\n");
+            break;
+        }
+
+        assert(offset >= 0 && offset < (s64a)ci->len);
+        u8 c = ci->buf[offset];
+        if (!reachHasBit(reach, c)) {
+            DEBUG_PRINTF("char 0x%02x failed reach check\n", c);
+            return 0;
+        }
+    }
+
+    DEBUG_PRINTF("OK :)\n");
+    return 1;
+}
+
+static
+int roseNfaEarliestSom(u64a from_offset, UNUSED u64a offset, UNUSED ReportID id,
+                       void *context) {
+    u64a *som = context;
+    *som = MIN(*som, from_offset);
+    return MO_CONTINUE_MATCHING;
+}
+
+static rose_inline
+u64a roseGetHaigSom(const struct RoseEngine *t, struct hs_scratch *scratch,
+                    const u32 qi, UNUSED const u32 leftfixLag) {
+    u32 ri = queueToLeftIndex(t, qi);
+
+    UNUSED const struct LeftNfaInfo *left = getLeftTable(t) + ri;
+
+    DEBUG_PRINTF("testing %s prefix %u/%u with lag %u (maxLag=%u)\n",
+                 left->transient ? "transient" : "active", ri, qi,
+                 leftfixLag, left->maxLag);
+
+    assert(leftfixLag <= left->maxLag);
+
+    struct mq *q = scratch->queues + qi;
+
+    u64a start = ~0ULL;
+
+    /* switch the callback + context for a fun one */
+    q->som_cb = roseNfaEarliestSom;
+    q->context = &start;
+
+    nfaReportCurrentMatches(q->nfa, q);
+
+    /* restore the old callback + context */
+    q->som_cb = roseNfaSomAdaptor;
+    q->context = NULL;
+    DEBUG_PRINTF("earliest som is %llu\n", start);
+    return start;
+}
+
+static rose_inline
+char roseCheckBounds(u64a end, u64a min_bound, u64a max_bound) {
+    DEBUG_PRINTF("check offset=%llu against bounds [%llu,%llu]\n", end,
+                 min_bound, max_bound);
+    assert(min_bound <= max_bound);
+    return end >= min_bound && end <= max_bound;
+}
+
+static
+void updateSeqPoint(struct RoseContext *tctxt, u64a offset,
+                    const char from_mpv) {
+    if (from_mpv) {
+        updateMinMatchOffsetFromMpv(tctxt, offset);
+    } else {
+        updateMinMatchOffset(tctxt, offset);
+    }
+}
+
+#define PROGRAM_CASE(name)                                                     \
+    case ROSE_INSTR_##name: {                                                  \
+        DEBUG_PRINTF("instruction: " #name " (pc=%u)\n",                       \
+                     programOffset + (u32)(pc - pc_base));                     \
+        const struct ROSE_STRUCT_##name *ri =                                  \
+            (const struct ROSE_STRUCT_##name *)pc;
+
+#define PROGRAM_NEXT_INSTRUCTION                                               \
+    pc += ROUNDUP_N(sizeof(*ri), ROSE_INSTR_MIN_ALIGN);                        \
+    break;                                                                     \
+    }
+
+static rose_inline
+hwlmcb_rv_t roseRunProgram(const struct RoseEngine *t,
+                           struct hs_scratch *scratch, u32 programOffset,
+                           u64a som, u64a end, size_t match_len,
+                           char in_anchored, char in_catchup, char from_mpv,
+                           char skip_mpv_catchup) {
+    DEBUG_PRINTF("program=%u, offsets [%llu,%llu]\n", programOffset, som, end);
+
+    assert(programOffset >= sizeof(struct RoseEngine));
+    assert(programOffset < t->size);
+
+    const char *pc_base = getByOffset(t, programOffset);
+    const char *pc = pc_base;
+
+    // Local sparse iterator state for programs that use the SPARSE_ITER_BEGIN
+    // and SPARSE_ITER_NEXT instructions.
+    struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES];
+
+    // If this program has an effect, work_done will be set to one (which may
+    // allow the program to squash groups).
+    int work_done = 0;
+
+    struct RoseContext *tctxt = &scratch->tctxt;
+
+    assert(*(const u8 *)pc != ROSE_INSTR_END);
+
+    for (;;) {
+        assert(ISALIGNED_N(pc, ROSE_INSTR_MIN_ALIGN));
+        assert(pc >= pc_base);
+        assert((size_t)(pc - pc_base) < t->size);
+        const u8 code = *(const u8 *)pc;
+        assert(code <= ROSE_INSTR_END);
+
+        switch ((enum RoseInstructionCode)code) {
+            PROGRAM_CASE(ANCHORED_DELAY) {
+                if (in_anchored && end > t->floatingMinLiteralMatchOffset) {
+                    DEBUG_PRINTF("delay until playback\n");
+                    tctxt->groups |= ri->groups;
+                    work_done = 1;
+                    assert(ri->done_jump); // must progress
+                    pc += ri->done_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_LIT_MASK) {
+                assert(match_len);
+                struct core_info *ci = &scratch->core_info;
+                if (!roseCheckBenefits(ci, end, match_len, ri->and_mask.a8,
+                                       ri->cmp_mask.a8)) {
+                    DEBUG_PRINTF("halt: failed mask check\n");
+                    return HWLM_CONTINUE_MATCHING;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_LIT_EARLY) {
+                if (end < t->floatingMinLiteralMatchOffset) {
+                    DEBUG_PRINTF("halt: too soon, min offset=%u\n",
+                                 t->floatingMinLiteralMatchOffset);
+                    return HWLM_CONTINUE_MATCHING;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_GROUPS) {
+                DEBUG_PRINTF("groups=0x%llx, checking instr groups=0x%llx\n",
+                             tctxt->groups, ri->groups);
+                if (!(ri->groups & tctxt->groups)) {
+                    DEBUG_PRINTF("halt: no groups are set\n");
+                    return HWLM_CONTINUE_MATCHING;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_ONLY_EOD) {
+                struct core_info *ci = &scratch->core_info;
+                if (end != ci->buf_offset + ci->len) {
+                    DEBUG_PRINTF("should only match at end of data\n");
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_BOUNDS) {
+                if (!roseCheckBounds(end, ri->min_bound, ri->max_bound)) {
+                    DEBUG_PRINTF("failed bounds check\n");
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_NOT_HANDLED) {
+                struct fatbit *handled = scratch->handled_roles;
+                if (fatbit_set(handled, t->handledKeyCount, ri->key)) {
+                    DEBUG_PRINTF("key %u already set\n", ri->key);
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_LOOKAROUND) {
+                if (!roseCheckLookaround(t, scratch, ri->index, ri->count,
+                                         end)) {
+                    DEBUG_PRINTF("failed lookaround check\n");
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_INFIX) {
+                if (!roseTestInfix(t, scratch, ri->queue, ri->lag, ri->report,
+                                   end)) {
+                    DEBUG_PRINTF("failed infix check\n");
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_PREFIX) {
+                if (!roseTestPrefix(t, scratch, ri->queue, ri->lag, ri->report,
+                                    end)) {
+                    DEBUG_PRINTF("failed prefix check\n");
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(PUSH_DELAYED) {
+                rosePushDelayedMatch(t, scratch, ri->delay, ri->index, end);
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CATCH_UP) {
+                if (roseCatchUpTo(t, scratch, end) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CATCH_UP_MPV) {
+                if (from_mpv || skip_mpv_catchup) {
+                    DEBUG_PRINTF("skipping mpv catchup\n");
+                } else if (roseCatchUpMPV(t,
+                                          end - scratch->core_info.buf_offset,
+                                          scratch) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SOM_ADJUST) {
+                assert(ri->distance <= end);
+                som = end - ri->distance;
+                DEBUG_PRINTF("som is (end - %u) = %llu\n", ri->distance, som);
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SOM_LEFTFIX) {
+                som = roseGetHaigSom(t, scratch, ri->queue, ri->lag);
+                DEBUG_PRINTF("som from leftfix is %llu\n", som);
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SOM_FROM_REPORT) {
+                som = handleSomExternal(scratch, &ri->som, end);
+                DEBUG_PRINTF("som from report %u is %llu\n", ri->som.onmatch,
+                             som);
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SOM_ZERO) {
+                DEBUG_PRINTF("setting SOM to zero\n");
+                som = 0;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(TRIGGER_INFIX) {
+                roseTriggerInfix(t, scratch, som, end, ri->queue, ri->event,
+                                 ri->cancel);
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(TRIGGER_SUFFIX) {
+                if (roseTriggerSuffix(t, scratch, ri->queue, ri->event, som,
+                                      end) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(DEDUPE) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                const char do_som = t->hasSom; // TODO: constant propagate
+                const char is_external_report = 1;
+                enum DedupeResult rv =
+                    dedupeCatchup(t, scratch, end, som, end + ri->offset_adjust,
+                                  ri->dkey, ri->offset_adjust,
+                                  is_external_report, ri->quash_som, do_som);
+                switch (rv) {
+                case DEDUPE_HALT:
+                    return HWLM_TERMINATE_MATCHING;
+                case DEDUPE_SKIP:
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                case DEDUPE_CONTINUE:
+                    break;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(DEDUPE_SOM) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                const char is_external_report = 0;
+                const char do_som = 1;
+                enum DedupeResult rv =
+                    dedupeCatchup(t, scratch, end, som, end + ri->offset_adjust,
+                                  ri->dkey, ri->offset_adjust,
+                                  is_external_report, ri->quash_som, do_som);
+                switch (rv) {
+                case DEDUPE_HALT:
+                    return HWLM_TERMINATE_MATCHING;
+                case DEDUPE_SKIP:
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                case DEDUPE_CONTINUE:
+                    break;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_CHAIN) {
+                // Note: sequence points updated inside this function.
+                if (roseCatchUpAndHandleChainMatch(
+                        t, scratch, ri->event, ri->top_squash_distance, end,
+                        in_catchup) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_SOM_INT) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                roseHandleSom(t, scratch, &ri->som, end);
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_SOM_AWARE) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                roseHandleSomSom(t, scratch, &ri->som, som, end);
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                if (roseReport(t, scratch, end, ri->onmatch, ri->offset_adjust,
+                               INVALID_EKEY) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_EXHAUST) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                if (roseReport(t, scratch, end, ri->onmatch, ri->offset_adjust,
+                               ri->ekey) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_SOM) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                if (roseReportSom(t, scratch, som, end, ri->onmatch,
+                                  ri->offset_adjust,
+                                  INVALID_EKEY) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_SOM_EXHAUST) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                if (roseReportSom(t, scratch, som, end, ri->onmatch,
+                                  ri->offset_adjust,
+                                  ri->ekey) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(DEDUPE_AND_REPORT) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                const char do_som = t->hasSom; // TODO: constant propagate
+                const char is_external_report = 1;
+                enum DedupeResult rv =
+                    dedupeCatchup(t, scratch, end, som, end + ri->offset_adjust,
+                                  ri->dkey, ri->offset_adjust,
+                                  is_external_report, ri->quash_som, do_som);
+                switch (rv) {
+                case DEDUPE_HALT:
+                    return HWLM_TERMINATE_MATCHING;
+                case DEDUPE_SKIP:
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                case DEDUPE_CONTINUE:
+                    break;
+                }
+
+                const u32 ekey = INVALID_EKEY;
+                if (roseReport(t, scratch, end, ri->onmatch, ri->offset_adjust,
+                               ekey) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(FINAL_REPORT) {
+                updateSeqPoint(tctxt, end, from_mpv);
+                if (roseReport(t, scratch, end, ri->onmatch, ri->offset_adjust,
+                               INVALID_EKEY) == HWLM_TERMINATE_MATCHING) {
+                    return HWLM_TERMINATE_MATCHING;
+                }
+                /* One-shot specialisation: this instruction always terminates
+                 * execution of the program. */
+                return HWLM_CONTINUE_MATCHING;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_EXHAUSTED) {
+                DEBUG_PRINTF("check ekey %u\n", ri->ekey);
+                assert(ri->ekey != INVALID_EKEY);
+                assert(ri->ekey < t->ekeyCount);
+                const char *evec = scratch->core_info.exhaustionVector;
+                if (isExhausted(t, evec, ri->ekey)) {
+                    DEBUG_PRINTF("ekey %u already set, match is exhausted\n",
+                                 ri->ekey);
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_MIN_LENGTH) {
+                DEBUG_PRINTF("check min length %llu (adj %d)\n", ri->min_length,
+                             ri->end_adj);
+                assert(ri->min_length > 0);
+                assert(ri->end_adj == 0 || ri->end_adj == -1);
+                assert(som == HS_OFFSET_PAST_HORIZON || som <= end);
+                if (som != HS_OFFSET_PAST_HORIZON &&
+                    ((end + ri->end_adj) - som < ri->min_length)) {
+                    DEBUG_PRINTF("failed check, match len %llu\n",
+                                 (u64a)((end + ri->end_adj) - som));
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SET_STATE) {
+                DEBUG_PRINTF("set state index %u\n", ri->index);
+                mmbit_set(getRoleState(scratch->core_info.state),
+                          t->rolesWithStateCount, ri->index);
+                work_done = 1;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SET_GROUPS) {
+                tctxt->groups |= ri->groups;
+                DEBUG_PRINTF("set groups 0x%llx -> 0x%llx\n", ri->groups,
+                             tctxt->groups);
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SQUASH_GROUPS) {
+                assert(popcount64(ri->groups) == 63); // Squash only one group.
+                if (work_done) {
+                    tctxt->groups &= ri->groups;
+                    DEBUG_PRINTF("squash groups 0x%llx -> 0x%llx\n", ri->groups,
+                                 tctxt->groups);
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_STATE) {
+                DEBUG_PRINTF("check state %u\n", ri->index);
+                const u8 *roles = getRoleState(scratch->core_info.state);
+                if (!mmbit_isset(roles, t->rolesWithStateCount, ri->index)) {
+                    DEBUG_PRINTF("state not on\n");
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SPARSE_ITER_BEGIN) {
+                DEBUG_PRINTF("iter_offset=%u\n", ri->iter_offset);
+                const struct mmbit_sparse_iter *it =
+                    getByOffset(t, ri->iter_offset);
+                assert(ISALIGNED(it));
+
+                const u8 *roles = getRoleState(scratch->core_info.state);
+
+                u32 idx = 0;
+                u32 i = mmbit_sparse_iter_begin(roles, t->rolesWithStateCount,
+                                                &idx, it, si_state);
+                if (i == MMB_INVALID) {
+                    DEBUG_PRINTF("no states in sparse iter are on\n");
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+
+                fatbit_clear(scratch->handled_roles);
+
+                const u32 *jumps = getByOffset(t, ri->jump_table);
+                DEBUG_PRINTF("state %u (idx=%u) is on, jump to %u\n", i, idx,
+                             jumps[idx]);
+                pc = pc_base + jumps[idx];
+                continue;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SPARSE_ITER_NEXT) {
+                DEBUG_PRINTF("iter_offset=%u, state=%u\n", ri->iter_offset,
+                             ri->state);
+                const struct mmbit_sparse_iter *it =
+                    getByOffset(t, ri->iter_offset);
+                assert(ISALIGNED(it));
+
+                const u8 *roles = getRoleState(scratch->core_info.state);
+
+                u32 idx = 0;
+                u32 i = mmbit_sparse_iter_next(roles, t->rolesWithStateCount,
+                                               ri->state, &idx, it, si_state);
+                if (i == MMB_INVALID) {
+                    DEBUG_PRINTF("no more states in sparse iter are on\n");
+                    assert(ri->fail_jump); // must progress
+                    pc += ri->fail_jump;
+                    continue;
+                }
+
+                const u32 *jumps = getByOffset(t, ri->jump_table);
+                DEBUG_PRINTF("state %u (idx=%u) is on, jump to %u\n", i, idx,
+                             jumps[idx]);
+                pc = pc_base + jumps[idx];
+                continue;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(END) {
+                DEBUG_PRINTF("finished\n");
+                return HWLM_CONTINUE_MATCHING;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+        }
+    }
+
+    assert(0); // unreachable
+    return HWLM_CONTINUE_MATCHING;
+}
+
+#undef PROGRAM_CASE
+#undef PROGRAM_NEXT_INSTRUCTION
+
+#endif // PROGRAM_RUNTIME_H
diff --git a/src/rose/rose.h b/src/rose/rose.h
index 6bebdf10..e90d2f21 100644
--- a/src/rose/rose.h
+++ b/src/rose/rose.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -37,23 +37,56 @@
 #include "util/multibit.h"
 
 // Initialise state space for engine use.
-void roseInitState(const struct RoseEngine *t, u8 *state);
+void roseInitState(const struct RoseEngine *t, char *state);
 
 void roseBlockEodExec(const struct RoseEngine *t, u64a offset,
                       struct hs_scratch *scratch);
-void roseBlockExec_i(const struct RoseEngine *t, struct hs_scratch *scratch,
-                     RoseCallback callback, RoseCallbackSom som_callback,
-                     void *context);
+void roseBlockExec_i(const struct RoseEngine *t, struct hs_scratch *scratch);
+
+static really_inline
+int roseBlockHasEodWork(const struct RoseEngine *t,
+                        struct hs_scratch *scratch) {
+    if (t->ematcherOffset) {
+        DEBUG_PRINTF("eod matcher to run\n");
+        return 1;
+    }
+
+    if (t->eodProgramOffset) {
+        DEBUG_PRINTF("has eod program\n");
+        return 1;
+    }
+
+    void *state = scratch->core_info.state;
+    if (mmbit_any(getActiveLeafArray(t, state), t->activeArrayCount)) {
+        DEBUG_PRINTF("active outfix/suffix engines\n");
+        return 1;
+    }
+
+    if (t->eodIterOffset) {
+        u32 idx;
+        const struct mmbit_sparse_iter *it = getByOffset(t, t->eodIterOffset);
+        struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES];
+        if (mmbit_sparse_iter_begin(getRoleState(state), t->rolesWithStateCount,
+                                    &idx, it, si_state) != MMB_INVALID) {
+            DEBUG_PRINTF("eod iter has states on\n");
+            return 1;
+        }
+    }
+
+    return 0;
+}
 
 /* assumes core_info in scratch has been init to point to data */
 static really_inline
-void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch,
-                   RoseCallback callback, RoseCallbackSom som_callback,
-                   void *context) {
+void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch) {
     assert(t);
     assert(scratch);
     assert(scratch->core_info.buf);
 
+    // We should not have been called if we've already been told to terminate
+    // matching.
+    assert(!told_to_stop_matching(scratch));
+
     // If this block is shorter than our minimum width, then no pattern in this
     // RoseEngine could match.
     /* minWidth checks should have already been performed by the caller */
@@ -66,7 +99,7 @@ void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch,
     assert(t->maxBiAnchoredWidth == ROSE_BOUND_INF
            || length <= t->maxBiAnchoredWidth);
 
-    roseBlockExec_i(t, scratch, callback, som_callback, context);
+    roseBlockExec_i(t, scratch);
 
     if (!t->requiresEodCheck) {
         return;
@@ -77,19 +110,8 @@ void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch,
         return;
     }
 
-    struct mmbit_sparse_state *s = scratch->sparse_iter_state;
-    const u32 numStates = t->rolesWithStateCount;
-    u8 *state = (u8 *)scratch->core_info.state;
-    void *role_state = getRoleState(state);
-    u32 idx = 0;
-    const struct mmbit_sparse_iter *it
-        = (const void *)((const u8 *)t + t->eodIterOffset);
-
-    if (!t->ematcherOffset && !t->hasEodEventLiteral
-        && !mmbit_any(getActiveLeafArray(t, state), t->activeArrayCount)
-        && (!t->eodIterOffset
-            || mmbit_sparse_iter_begin(role_state, numStates, &idx, it, s)
-            == MMB_INVALID)) {
+    if (!roseBlockHasEodWork(t, scratch)) {
+        DEBUG_PRINTF("no eod work\n");
         return;
     }
 
@@ -97,14 +119,18 @@ void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch,
 }
 
 /* assumes core_info in scratch has been init to point to data */
-void roseStreamExec(const struct RoseEngine *t, u8 *state,
-                    struct hs_scratch *scratch, RoseCallback callback,
-                    RoseCallbackSom som_callback, void *context);
+void roseStreamExec(const struct RoseEngine *t, struct hs_scratch *scratch);
 
-void roseEodExec(const struct RoseEngine *t, u8 *state, u64a offset,
-                 struct hs_scratch *scratch, RoseCallback callback,
-                 RoseCallbackSom som_callback, void *context);
+void roseEodExec(const struct RoseEngine *t, u64a offset,
+                 struct hs_scratch *scratch);
 
-#define ROSE_CONTINUE_MATCHING_NO_EXHAUST 2
+hwlmcb_rv_t rosePureLiteralCallback(size_t start, size_t end, u32 id,
+                                    void *context);
+
+int roseReportAdaptor(u64a offset, ReportID id, void *context);
+int roseReportSomAdaptor(u64a som, u64a offset, ReportID id, void *context);
+
+int roseRunBoundaryProgram(const struct RoseEngine *rose, u32 program,
+                           u64a stream_offset, struct hs_scratch *scratch);
 
 #endif // ROSE_H
diff --git a/src/rose/rose_build_add.cpp b/src/rose/rose_build_add.cpp
index cbd46df6..23c122a7 100644
--- a/src/rose/rose_build_add.cpp
+++ b/src/rose/rose_build_add.cpp
@@ -115,7 +115,6 @@ RoseVertex createVertex(RoseBuildImpl *build, u32 literalId, u32 min_offset,
     g[v].idx = build->vertexIndex++;
     g[v].min_offset = min_offset;
     g[v].max_offset = max_offset;
-    /* no escapes */
 
     DEBUG_PRINTF("insert vertex %zu into literal %u's vertex set\n", g[v].idx,
                  literalId);
@@ -201,19 +200,16 @@ RoseVertex duplicate(RoseBuildImpl *build, RoseVertex v) {
 namespace {
 struct created_key {
     explicit created_key(const RoseInEdgeProps &trep)
-        : prefix(trep.graph.get()), lag(trep.graph_lag), escapes(trep.escapes) {
-        assert(escapes.none() || !prefix);
+        : prefix(trep.graph.get()), lag(trep.graph_lag) {
     }
     bool operator<(const created_key &b) const {
         const created_key &a = *this;
         ORDER_CHECK(prefix);
         ORDER_CHECK(lag);
-        ORDER_CHECK(escapes);
         return false;
     }
     NGHolder *prefix;
     u32 lag;
-    CharReach escapes;
 };
 }
 
@@ -320,15 +316,6 @@ void createVertices(RoseBuildImpl *tbi,
         }
 
         NFAVertex p = pv.first;
-        if (isLeafNode(p, g)) {
-            DEBUG_PRINTF("setting escapes (reach %s) on parent\n",
-                         describeClass(key.escapes, 20, CC_OUT_TEXT).c_str());
-            g[p].escapes = key.escapes;
-        } else if (key.escapes != g[p].escapes) {
-            DEBUG_PRINTF("creating differently escaped version of parent\n");
-            p = duplicate(tbi, p);
-            g[p].escapes = key.escapes;
-        }
 
         RoseEdge e;
         bool added;
@@ -1052,6 +1039,7 @@ bool canImplementGraph(RoseBuildImpl *tbi, const RoseInGraph &in, NGHolder &h,
             }
             break;
         case NFA_REV_PREFIX:
+        case NFA_OUTFIX_RAW:
             DEBUG_PRINTF("kind %u\n", (u32)h.kind);
             assert(0);
         }
@@ -1106,10 +1094,6 @@ bool predsAreDelaySensitive(const RoseInGraph &ig, RoseInVertex v) {
             DEBUG_PRINTF("edge bounds\n");
             return true;
         }
-        if (ig[e].escapes.any()) {
-            DEBUG_PRINTF("escapes\n");
-            return true;
-        }
 
         RoseInVertex u = source(e, ig);
         if (ig[u].type == RIV_START) {
@@ -1793,11 +1777,12 @@ bool RoseBuildImpl::addOutfix(const NGHolder &h, const raw_som_dfa &haig) {
 
 bool RoseBuildImpl::addOutfix(const raw_puff &rp) {
     if (!mpv_outfix) {
-        mpv_outfix = make_unique<OutfixInfo>();
-        mpv_outfix->chained = true;
+        mpv_outfix = make_unique<OutfixInfo>(MpvProto());
     }
 
-    mpv_outfix->puffettes.push_back(rp);
+    auto *mpv = mpv_outfix->mpv();
+    assert(mpv);
+    mpv->puffettes.push_back(rp);
 
     mpv_outfix->maxBAWidth = ROSE_BOUND_INF; /* not ba */
     mpv_outfix->minWidth = min(mpv_outfix->minWidth, depth(rp.repeats));
@@ -1817,11 +1802,12 @@ bool RoseBuildImpl::addOutfix(const raw_puff &rp) {
 bool RoseBuildImpl::addChainTail(const raw_puff &rp, u32 *queue_out,
                                  u32 *event_out) {
     if (!mpv_outfix) {
-        mpv_outfix = make_unique<OutfixInfo>();
-        mpv_outfix->chained = true;
+        mpv_outfix = make_unique<OutfixInfo>(MpvProto());
     }
 
-    mpv_outfix->triggered_puffettes.push_back(rp);
+    auto *mpv = mpv_outfix->mpv();
+    assert(mpv);
+    mpv->triggered_puffettes.push_back(rp);
 
     mpv_outfix->maxBAWidth = ROSE_BOUND_INF; /* not ba */
     mpv_outfix->minWidth = min(mpv_outfix->minWidth, depth(rp.repeats));
@@ -1833,7 +1819,7 @@ bool RoseBuildImpl::addChainTail(const raw_puff &rp, u32 *queue_out,
                                             * the caller */
 
     *queue_out = mpv_outfix->get_queue(qif);
-    *event_out = MQE_TOP_FIRST + mpv_outfix->triggered_puffettes.size() - 1;
+    *event_out = MQE_TOP_FIRST + mpv->triggered_puffettes.size() - 1;
 
     return true; /* failure is not yet an option */
 }
diff --git a/src/rose/rose_build_anchored.cpp b/src/rose/rose_build_anchored.cpp
index 675f8c68..35ff7138 100644
--- a/src/rose/rose_build_anchored.cpp
+++ b/src/rose/rose_build_anchored.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -217,13 +217,8 @@ void populate_holder(const simple_anchored_info &sai, const set<u32> &exit_ids,
     h[v].reports.insert(exit_ids.begin(), exit_ids.end());
 }
 
-u32 anchoredStateSize(const void *atable) {
-    if (!atable) {
-        return 0;
-    }
-
-    const struct anchored_matcher_info *curr
-        = (const anchored_matcher_info *)atable;
+u32 anchoredStateSize(const anchored_matcher_info &atable) {
+    const struct anchored_matcher_info *curr = &atable;
 
     // Walk the list until we find the last element; total state size will be
     // that engine's state offset plus its state requirement.
@@ -233,17 +228,9 @@ u32 anchoredStateSize(const void *atable) {
     }
 
     const NFA *nfa = (const NFA *)((const char *)curr + sizeof(*curr));
-    return curr->state_offset + nfa->scratchStateSize;
+    return curr->state_offset + nfa->streamStateSize;
 }
 
-bool anchoredIsMulti(const RoseEngine &engine) {
-    const struct anchored_matcher_info *curr
-        = (const anchored_matcher_info *)getALiteralMatcher(&engine);
-
-    return curr && curr->next_offset;
- }
-
-
 namespace {
 
 typedef bitfield<ANCHORED_NFA_STATE_LIMIT> nfa_state_set;
@@ -673,7 +660,7 @@ int addAutomaton(RoseBuildImpl &tbi, const NGHolder &h, ReportID *remap) {
 
     Automaton_Holder autom(h);
 
-    unique_ptr<raw_dfa> out_dfa = ue2::make_unique<raw_dfa>(NFA_OUTFIX);
+    unique_ptr<raw_dfa> out_dfa = ue2::make_unique<raw_dfa>(NFA_OUTFIX_RAW);
     if (!determinise(autom, out_dfa->states, MAX_DFA_STATES)) {
         return finalise_out(tbi, h, autom, move(out_dfa), remap);
     }
@@ -734,7 +721,7 @@ void buildSimpleDfas(const RoseBuildImpl &tbi,
         NGHolder h;
         populate_holder(simple.first, exit_ids, &h);
         Automaton_Holder autom(h);
-        unique_ptr<raw_dfa> rdfa = ue2::make_unique<raw_dfa>(NFA_OUTFIX);
+        unique_ptr<raw_dfa> rdfa = ue2::make_unique<raw_dfa>(NFA_OUTFIX_RAW);
         UNUSED int rv = determinise(autom, rdfa->states, MAX_DFA_STATES);
         assert(!rv);
         rdfa->start_anchored = INIT_STATE;
@@ -751,21 +738,24 @@ void buildSimpleDfas(const RoseBuildImpl &tbi,
  * from RoseBuildImpl.
  */
 static
-void getAnchoredDfas(RoseBuildImpl &tbi,
-                     vector<unique_ptr<raw_dfa>> *anchored_dfas) {
+vector<unique_ptr<raw_dfa>> getAnchoredDfas(RoseBuildImpl &build) {
+    vector<unique_ptr<raw_dfa>> dfas;
+
     // DFAs that already exist as raw_dfas.
-    for (auto &anch_dfas : tbi.anchored_nfas) {
+    for (auto &anch_dfas : build.anchored_nfas) {
         for (auto &rdfa : anch_dfas.second) {
-            anchored_dfas->push_back(move(rdfa));
+            dfas.push_back(move(rdfa));
         }
     }
-    tbi.anchored_nfas.clear();
+    build.anchored_nfas.clear();
 
     // DFAs we currently have as simple literals.
-    if (!tbi.anchored_simple.empty()) {
-        buildSimpleDfas(tbi, anchored_dfas);
-        tbi.anchored_simple.clear();
+    if (!build.anchored_simple.empty()) {
+        buildSimpleDfas(build, &dfas);
+        build.anchored_simple.clear();
     }
+
+    return dfas;
 }
 
 /**
@@ -779,9 +769,10 @@ void getAnchoredDfas(RoseBuildImpl &tbi,
  * \return Total bytes required for the complete anchored matcher.
  */
 static
-size_t buildNfas(vector<unique_ptr<raw_dfa>> &anchored_dfas,
-                 vector<aligned_unique_ptr<NFA>> *nfas, vector<u32> *start_offset,
-                 const CompileContext &cc) {
+size_t buildNfas(vector<raw_dfa> &anchored_dfas,
+                 vector<aligned_unique_ptr<NFA>> *nfas,
+                 vector<u32> *start_offset, const CompileContext &cc,
+                 const ReportManager &rm) {
     const size_t num_dfas = anchored_dfas.size();
 
     nfas->reserve(num_dfas);
@@ -790,12 +781,12 @@ size_t buildNfas(vector<unique_ptr<raw_dfa>> &anchored_dfas,
     size_t total_size = 0;
 
     for (auto &rdfa : anchored_dfas) {
-        u32 removed_dots = remove_leading_dots(*rdfa);
+        u32 removed_dots = remove_leading_dots(rdfa);
         start_offset->push_back(removed_dots);
 
-        minimize_hopcroft(*rdfa, cc.grey);
+        minimize_hopcroft(rdfa, cc.grey);
 
-        aligned_unique_ptr<NFA> nfa = mcclellanCompile(*rdfa, cc);
+        auto nfa = mcclellanCompile(rdfa, cc, rm);
         if (!nfa) {
             assert(0);
             throw std::bad_alloc();
@@ -812,32 +803,48 @@ size_t buildNfas(vector<unique_ptr<raw_dfa>> &anchored_dfas,
     return total_size;
 }
 
-aligned_unique_ptr<void> buildAnchoredAutomataMatcher(RoseBuildImpl &tbi,
-                                                      size_t *asize) {
-    const CompileContext &cc = tbi.cc;
-    remapAnchoredReports(tbi);
+vector<raw_dfa> buildAnchoredDfas(RoseBuildImpl &build) {
+    vector<raw_dfa> dfas;
 
-    if (tbi.anchored_nfas.empty() && tbi.anchored_simple.empty()) {
+    if (build.anchored_nfas.empty() && build.anchored_simple.empty()) {
+        DEBUG_PRINTF("empty\n");
+        return dfas;
+    }
+
+    remapAnchoredReports(build);
+
+    auto anch_dfas = getAnchoredDfas(build);
+    mergeAnchoredDfas(anch_dfas, build);
+
+    dfas.reserve(anch_dfas.size());
+    for (auto &rdfa : anch_dfas) {
+        assert(rdfa);
+        dfas.push_back(move(*rdfa));
+    }
+    return dfas;
+}
+
+aligned_unique_ptr<anchored_matcher_info>
+buildAnchoredMatcher(RoseBuildImpl &build, vector<raw_dfa> &dfas,
+                     size_t *asize) {
+    const CompileContext &cc = build.cc;
+
+    if (dfas.empty()) {
         DEBUG_PRINTF("empty\n");
         *asize = 0;
         return nullptr;
     }
 
-    vector<unique_ptr<raw_dfa>> anchored_dfas;
-    getAnchoredDfas(tbi, &anchored_dfas);
-
-    mergeAnchoredDfas(anchored_dfas, tbi);
-
     vector<aligned_unique_ptr<NFA>> nfas;
     vector<u32> start_offset; // start offset for each dfa (dots removed)
-    size_t total_size = buildNfas(anchored_dfas, &nfas, &start_offset, cc);
+    size_t total_size = buildNfas(dfas, &nfas, &start_offset, cc, build.rm);
 
     if (total_size > cc.grey.limitRoseAnchoredSize) {
         throw ResourceLimitError();
     }
 
     *asize = total_size;
-    aligned_unique_ptr<void> atable = aligned_zmalloc_unique<void>(total_size);
+    auto atable = aligned_zmalloc_unique<anchored_matcher_info>(total_size);
     char *curr = (char *)atable.get();
 
     u32 state_offset = 0;
@@ -858,15 +865,8 @@ aligned_unique_ptr<void> buildAnchoredAutomataMatcher(RoseBuildImpl &tbi,
             ami->next_offset = verify_u32(curr - prev_curr);
         }
 
-        // State must be aligned.
-        u32 align_req = state_alignment(*nfa);
-        assert(align_req <= 2); // only DFAs.
-        while (state_offset % align_req) {
-            state_offset++;
-        }
-
         ami->state_offset = state_offset;
-        state_offset += nfa->scratchStateSize;
+        state_offset += nfa->streamStateSize;
         ami->anchoredMinDistance = start_offset[i];
     }
 
diff --git a/src/rose/rose_build_anchored.h b/src/rose/rose_build_anchored.h
index 1ee8be74..a5317f89 100644
--- a/src/rose/rose_build_anchored.h
+++ b/src/rose/rose_build_anchored.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -38,6 +38,7 @@
 #include <vector>
 #include <set>
 
+struct anchored_matcher_info;
 struct RoseEngine;
 
 namespace ue2 {
@@ -45,11 +46,22 @@ namespace ue2 {
 class NGHolder;
 class RoseBuildImpl;
 struct Grey;
+struct raw_dfa;
 
-aligned_unique_ptr<void> buildAnchoredAutomataMatcher(RoseBuildImpl &tbi,
-                                                      size_t *asize);
-u32 anchoredStateSize(const void *atable);
-bool anchoredIsMulti(const RoseEngine &engine);
+/**
+ * \brief Construct a set of anchored DFAs from our anchored literals/engines.
+ */
+std::vector<raw_dfa> buildAnchoredDfas(RoseBuildImpl &build);
+
+/**
+ * \brief Construct an anchored_matcher_info runtime structure from the given
+ * set of DFAs.
+ */
+aligned_unique_ptr<anchored_matcher_info>
+buildAnchoredMatcher(RoseBuildImpl &build, std::vector<raw_dfa> &dfas,
+                     size_t *asize);
+
+u32 anchoredStateSize(const anchored_matcher_info &atable);
 
 #define ANCHORED_FAIL    0
 #define ANCHORED_SUCCESS 1
diff --git a/src/rose/rose_build_bytecode.cpp b/src/rose/rose_build_bytecode.cpp
index e17953aa..758dd442 100644
--- a/src/rose/rose_build_bytecode.cpp
+++ b/src/rose/rose_build_bytecode.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -35,14 +35,16 @@
 #include "rose_build_anchored.h"
 #include "rose_build_infix.h"
 #include "rose_build_lookaround.h"
+#include "rose_build_matchers.h"
 #include "rose_build_scatter.h"
 #include "rose_build_util.h"
 #include "rose_build_width.h"
+#include "rose_program.h"
 #include "hwlm/hwlm.h" /* engine types */
-#include "hwlm/hwlm_build.h"
 #include "nfa/castlecompile.h"
 #include "nfa/goughcompile.h"
 #include "nfa/mcclellancompile.h"
+#include "nfa/mcclellancompile_util.h"
 #include "nfa/nfa_api_queue.h"
 #include "nfa/nfa_build_util.h"
 #include "nfa/nfa_internal.h"
@@ -57,8 +59,6 @@
 #include "nfagraph/ng_stop.h"
 #include "nfagraph/ng_util.h"
 #include "nfagraph/ng_width.h"
-#include "sidecar/sidecar.h"
-#include "sidecar/sidecar_compile.h"
 #include "som/slot_manager.h"
 #include "util/alloc.h"
 #include "util/bitutils.h"
@@ -69,8 +69,6 @@
 #include "util/compile_error.h"
 #include "util/container.h"
 #include "util/graph_range.h"
-#include "util/dump_charclass.h"
-#include "util/internal_report.h"
 #include "util/multibit_build.h"
 #include "util/order_check.h"
 #include "util/queue_index_factory.h"
@@ -79,11 +77,9 @@
 #include "util/verify_types.h"
 
 #include <algorithm>
-#include <iomanip>
 #include <map>
 #include <queue>
 #include <set>
-#include <sstream>
 #include <string>
 #include <vector>
 #include <utility>
@@ -116,63 +112,20 @@ namespace ue2 {
 
 namespace /* anon */ {
 
-// Orders RoseEdge edges by the state index of the source node
-struct EdgeSourceStateCompare {
-    EdgeSourceStateCompare(const RoseGraph &g_,
-                           const vector<RoseRole> &roleTable_) :
-                                g(g_), roleTable(roleTable_) {}
-    bool operator()(const RoseEdge &a, const RoseEdge &b) const {
-        u32 arole = g[source(a, g)].role;
-        u32 brole = g[source(b, g)].role;
-        if (arole >= roleTable.size()) {
-            DEBUG_PRINTF("bad arole %u (idx=%zu)\n", arole, g[source(a, g)].idx);
-        }
-        if (brole >= roleTable.size()) {
-            DEBUG_PRINTF("bad brole %u (idx=%zu)\n", brole, g[source(b, g)].idx);
-        }
-        assert(arole < roleTable.size());
-        assert(brole < roleTable.size());
-        return roleTable.at(arole).stateIndex < roleTable.at(brole).stateIndex;
-    }
-    const RoseGraph &g;
-    const vector<RoseRole> &roleTable;
-};
-
-struct RoseTriggerOrdering {
-    RoseTriggerOrdering() {}
-    bool operator()(const RoseTrigger &a, const RoseTrigger &b) const {
-        ORDER_CHECK(queue);
-        ORDER_CHECK(event);
-        ORDER_CHECK(cancel_prev_top);
-        return false;
-    }
-};
-struct RoseTriggerEquality {
-    RoseTriggerEquality() {}
-    bool operator()(const RoseTrigger &a, const RoseTrigger &b) const {
-        return a.queue == b.queue
-            && a.event == b.event
-            && a.cancel_prev_top == b.cancel_prev_top;
-    }
-};
-
 struct left_build_info {
     // Constructor for an engine implementation.
-    left_build_info(NFA *n, u32 q, u32 l, u32 t, rose_group sm,
+    left_build_info(u32 q, u32 l, u32 t, rose_group sm,
                     const std::vector<u8> &stops, u32 max_ql, u8 cm_count,
                     const CharReach &cm_cr)
-        : nfa(n), queue(q), lag(l), transient(t), squash_mask(sm),
-          stopAlphabet(stops), max_queuelen(max_ql),
-          countingMiracleCount(cm_count), countingMiracleReach(cm_cr) {
-        assert(n);
-    }
+        : queue(q), lag(l), transient(t), squash_mask(sm), stopAlphabet(stops),
+          max_queuelen(max_ql), countingMiracleCount(cm_count),
+          countingMiracleReach(cm_cr) {}
 
     // Constructor for a lookaround implementation.
     explicit left_build_info(const vector<LookEntry> &look)
         : has_lookaround(true), lookaround(look) {}
 
-    NFA *nfa = nullptr; /* uniquely idents the left_build_info */
-    u32 queue = 0; /* also uniquely idents the left_build_info */
+    u32 queue = 0; /* uniquely idents the left_build_info */
     u32 lag = 0;
     u32 transient = 0;
     rose_group squash_mask = ~rose_group{0};
@@ -185,57 +138,367 @@ struct left_build_info {
     vector<LookEntry> lookaround; // alternative implementation to the NFA
 };
 
+/**
+ * \brief Possible jump targets for roles that perform checks.
+ *
+ * Fixed up into offsets before the program is written to bytecode.
+ */
+enum class JumpTarget {
+    NO_JUMP,        //!< Instruction does not jump.
+    PROGRAM_END,    //!< Jump to end of program.
+    NEXT_BLOCK,     //!< Jump to start of next block (sparse iter check, etc).
+    FIXUP_DONE,     //!< Target fixup already applied.
+};
+
+/** \brief Role instruction model used at compile time. */
+class RoseInstruction {
+public:
+    RoseInstruction(enum RoseInstructionCode c, JumpTarget j) : target(j) {
+        memset(&u, 0, sizeof(u));
+        u.end.code = c;
+    }
+
+    explicit RoseInstruction(enum RoseInstructionCode c)
+        : RoseInstruction(c, JumpTarget::NO_JUMP) {}
+
+    bool operator<(const RoseInstruction &a) const {
+        if (code() != a.code()) {
+            return code() < a.code();
+        }
+        if (target != a.target) {
+            return target < a.target;
+        }
+        return memcmp(&u, &a.u, sizeof(u)) < 0;
+    }
+
+    bool operator==(const RoseInstruction &a) const {
+        return code() == a.code() && target == a.target &&
+               memcmp(&u, &a.u, sizeof(u)) == 0;
+    }
+
+    enum RoseInstructionCode code() const {
+        // Note that this sort of type-punning (relying on identical initial
+        // layout) is explicitly allowed by the C++11 standard.
+        return (enum RoseInstructionCode)u.end.code;
+    }
+
+    const void *get() const {
+        switch (code()) {
+        case ROSE_INSTR_CHECK_LIT_MASK: return &u.checkLitMask;
+        case ROSE_INSTR_CHECK_LIT_EARLY: return &u.checkLitEarly;
+        case ROSE_INSTR_CHECK_GROUPS: return &u.checkGroups;
+        case ROSE_INSTR_CHECK_ONLY_EOD: return &u.checkOnlyEod;
+        case ROSE_INSTR_CHECK_BOUNDS: return &u.checkBounds;
+        case ROSE_INSTR_CHECK_NOT_HANDLED: return &u.checkNotHandled;
+        case ROSE_INSTR_CHECK_LOOKAROUND: return &u.checkLookaround;
+        case ROSE_INSTR_CHECK_INFIX: return &u.checkInfix;
+        case ROSE_INSTR_CHECK_PREFIX: return &u.checkPrefix;
+        case ROSE_INSTR_ANCHORED_DELAY: return &u.anchoredDelay;
+        case ROSE_INSTR_PUSH_DELAYED: return &u.pushDelayed;
+        case ROSE_INSTR_CATCH_UP: return &u.catchUp;
+        case ROSE_INSTR_CATCH_UP_MPV: return &u.catchUpMpv;
+        case ROSE_INSTR_SOM_ADJUST: return &u.somAdjust;
+        case ROSE_INSTR_SOM_LEFTFIX: return &u.somLeftfix;
+        case ROSE_INSTR_SOM_FROM_REPORT: return &u.somFromReport;
+        case ROSE_INSTR_SOM_ZERO: return &u.somZero;
+        case ROSE_INSTR_TRIGGER_INFIX: return &u.triggerInfix;
+        case ROSE_INSTR_TRIGGER_SUFFIX: return &u.triggerSuffix;
+        case ROSE_INSTR_DEDUPE: return &u.dedupe;
+        case ROSE_INSTR_DEDUPE_SOM: return &u.dedupeSom;
+        case ROSE_INSTR_REPORT_CHAIN: return &u.reportChain;
+        case ROSE_INSTR_REPORT_SOM_INT: return &u.reportSomInt;
+        case ROSE_INSTR_REPORT_SOM_AWARE: return &u.reportSomAware;
+        case ROSE_INSTR_REPORT: return &u.report;
+        case ROSE_INSTR_REPORT_EXHAUST: return &u.reportExhaust;
+        case ROSE_INSTR_REPORT_SOM: return &u.reportSom;
+        case ROSE_INSTR_REPORT_SOM_EXHAUST: return &u.reportSomExhaust;
+        case ROSE_INSTR_DEDUPE_AND_REPORT: return &u.dedupeAndReport;
+        case ROSE_INSTR_FINAL_REPORT: return &u.finalReport;
+        case ROSE_INSTR_CHECK_EXHAUSTED: return &u.checkExhausted;
+        case ROSE_INSTR_CHECK_MIN_LENGTH: return &u.checkMinLength;
+        case ROSE_INSTR_SET_STATE: return &u.setState;
+        case ROSE_INSTR_SET_GROUPS: return &u.setGroups;
+        case ROSE_INSTR_SQUASH_GROUPS: return &u.squashGroups;
+        case ROSE_INSTR_CHECK_STATE: return &u.checkState;
+        case ROSE_INSTR_SPARSE_ITER_BEGIN: return &u.sparseIterBegin;
+        case ROSE_INSTR_SPARSE_ITER_NEXT: return &u.sparseIterNext;
+        case ROSE_INSTR_END: return &u.end;
+        }
+        assert(0);
+        return &u.end;
+    }
+
+    size_t length() const {
+        switch (code()) {
+        case ROSE_INSTR_CHECK_LIT_MASK: return sizeof(u.checkLitMask);
+        case ROSE_INSTR_CHECK_LIT_EARLY: return sizeof(u.checkLitEarly);
+        case ROSE_INSTR_CHECK_GROUPS: return sizeof(u.checkGroups);
+        case ROSE_INSTR_CHECK_ONLY_EOD: return sizeof(u.checkOnlyEod);
+        case ROSE_INSTR_CHECK_BOUNDS: return sizeof(u.checkBounds);
+        case ROSE_INSTR_CHECK_NOT_HANDLED: return sizeof(u.checkNotHandled);
+        case ROSE_INSTR_CHECK_LOOKAROUND: return sizeof(u.checkLookaround);
+        case ROSE_INSTR_CHECK_INFIX: return sizeof(u.checkInfix);
+        case ROSE_INSTR_CHECK_PREFIX: return sizeof(u.checkPrefix);
+        case ROSE_INSTR_ANCHORED_DELAY: return sizeof(u.anchoredDelay);
+        case ROSE_INSTR_PUSH_DELAYED: return sizeof(u.pushDelayed);
+        case ROSE_INSTR_CATCH_UP: return sizeof(u.catchUp);
+        case ROSE_INSTR_CATCH_UP_MPV: return sizeof(u.catchUpMpv);
+        case ROSE_INSTR_SOM_ADJUST: return sizeof(u.somAdjust);
+        case ROSE_INSTR_SOM_LEFTFIX: return sizeof(u.somLeftfix);
+        case ROSE_INSTR_SOM_FROM_REPORT: return sizeof(u.somFromReport);
+        case ROSE_INSTR_SOM_ZERO: return sizeof(u.somZero);
+        case ROSE_INSTR_TRIGGER_INFIX: return sizeof(u.triggerInfix);
+        case ROSE_INSTR_TRIGGER_SUFFIX: return sizeof(u.triggerSuffix);
+        case ROSE_INSTR_DEDUPE: return sizeof(u.dedupe);
+        case ROSE_INSTR_DEDUPE_SOM: return sizeof(u.dedupeSom);
+        case ROSE_INSTR_REPORT_CHAIN: return sizeof(u.reportChain);
+        case ROSE_INSTR_REPORT_SOM_INT: return sizeof(u.reportSomInt);
+        case ROSE_INSTR_REPORT_SOM_AWARE: return sizeof(u.reportSomAware);
+        case ROSE_INSTR_REPORT: return sizeof(u.report);
+        case ROSE_INSTR_REPORT_EXHAUST: return sizeof(u.reportExhaust);
+        case ROSE_INSTR_REPORT_SOM: return sizeof(u.reportSom);
+        case ROSE_INSTR_REPORT_SOM_EXHAUST: return sizeof(u.reportSomExhaust);
+        case ROSE_INSTR_DEDUPE_AND_REPORT: return sizeof(u.dedupeAndReport);
+        case ROSE_INSTR_FINAL_REPORT: return sizeof(u.finalReport);
+        case ROSE_INSTR_CHECK_EXHAUSTED: return sizeof(u.checkExhausted);
+        case ROSE_INSTR_CHECK_MIN_LENGTH: return sizeof(u.checkMinLength);
+        case ROSE_INSTR_SET_STATE: return sizeof(u.setState);
+        case ROSE_INSTR_SET_GROUPS: return sizeof(u.setGroups);
+        case ROSE_INSTR_SQUASH_GROUPS: return sizeof(u.squashGroups);
+        case ROSE_INSTR_CHECK_STATE: return sizeof(u.checkState);
+        case ROSE_INSTR_SPARSE_ITER_BEGIN: return sizeof(u.sparseIterBegin);
+        case ROSE_INSTR_SPARSE_ITER_NEXT: return sizeof(u.sparseIterNext);
+        case ROSE_INSTR_END: return sizeof(u.end);
+        }
+        assert(0);
+        return 0;
+    }
+
+    union {
+        ROSE_STRUCT_CHECK_LIT_MASK checkLitMask;
+        ROSE_STRUCT_CHECK_LIT_EARLY checkLitEarly;
+        ROSE_STRUCT_CHECK_GROUPS checkGroups;
+        ROSE_STRUCT_CHECK_ONLY_EOD checkOnlyEod;
+        ROSE_STRUCT_CHECK_BOUNDS checkBounds;
+        ROSE_STRUCT_CHECK_NOT_HANDLED checkNotHandled;
+        ROSE_STRUCT_CHECK_LOOKAROUND checkLookaround;
+        ROSE_STRUCT_CHECK_INFIX checkInfix;
+        ROSE_STRUCT_CHECK_PREFIX checkPrefix;
+        ROSE_STRUCT_ANCHORED_DELAY anchoredDelay;
+        ROSE_STRUCT_PUSH_DELAYED pushDelayed;
+        ROSE_STRUCT_CATCH_UP catchUp;
+        ROSE_STRUCT_CATCH_UP_MPV catchUpMpv;
+        ROSE_STRUCT_SOM_ADJUST somAdjust;
+        ROSE_STRUCT_SOM_LEFTFIX somLeftfix;
+        ROSE_STRUCT_SOM_FROM_REPORT somFromReport;
+        ROSE_STRUCT_SOM_ZERO somZero;
+        ROSE_STRUCT_TRIGGER_INFIX triggerInfix;
+        ROSE_STRUCT_TRIGGER_SUFFIX triggerSuffix;
+        ROSE_STRUCT_DEDUPE dedupe;
+        ROSE_STRUCT_DEDUPE_SOM dedupeSom;
+        ROSE_STRUCT_REPORT_CHAIN reportChain;
+        ROSE_STRUCT_REPORT_SOM_INT reportSomInt;
+        ROSE_STRUCT_REPORT_SOM_AWARE reportSomAware;
+        ROSE_STRUCT_REPORT report;
+        ROSE_STRUCT_REPORT_EXHAUST reportExhaust;
+        ROSE_STRUCT_REPORT_SOM reportSom;
+        ROSE_STRUCT_REPORT_SOM_EXHAUST reportSomExhaust;
+        ROSE_STRUCT_DEDUPE_AND_REPORT dedupeAndReport;
+        ROSE_STRUCT_FINAL_REPORT finalReport;
+        ROSE_STRUCT_CHECK_EXHAUSTED checkExhausted;
+        ROSE_STRUCT_CHECK_MIN_LENGTH checkMinLength;
+        ROSE_STRUCT_SET_STATE setState;
+        ROSE_STRUCT_SET_GROUPS setGroups;
+        ROSE_STRUCT_SQUASH_GROUPS squashGroups;
+        ROSE_STRUCT_CHECK_STATE checkState;
+        ROSE_STRUCT_SPARSE_ITER_BEGIN sparseIterBegin;
+        ROSE_STRUCT_SPARSE_ITER_NEXT sparseIterNext;
+        ROSE_STRUCT_END end;
+    } u;
+
+    JumpTarget target;
+};
+
+static
+size_t hash_value(const RoseInstruction &ri) {
+    size_t val = 0;
+    boost::hash_combine(val, ri.code());
+    boost::hash_combine(val, ri.target);
+    const char *bytes = (const char *)ri.get();
+    const size_t len = ri.length();
+    for (size_t i = 0; i < len; i++) {
+        boost::hash_combine(val, bytes[i]);
+    }
+    return val;
+}
+
+/**
+ * \brief Structure tracking which resources are used by this Rose instance at
+ * runtime.
+ *
+ * We use this to control how much initialisation we need to do at the
+ * beginning of a stream/block at runtime.
+ */
+struct RoseResources {
+    bool has_outfixes = false;
+    bool has_suffixes = false;
+    bool has_leftfixes = false;
+    bool has_literals = false;
+    bool has_states = false;
+    bool checks_groups = false;
+    bool has_lit_delay = false;
+    bool has_lit_mask = false;
+    bool has_anchored = false;
+};
+
 struct build_context : boost::noncopyable {
-    /** \brief Rose Role information.
-     * These entries are filled in by a number of functions as other tables are
-     * created.
-     */
-    vector<RoseRole> roleTable;
-
-    /** \brief minimum depth in number of hops from root/anchored root. */
-    map<RoseVertex, u32> depths;
-
     /** \brief information about engines to the left of a vertex */
     map<RoseVertex, left_build_info> leftfix_info;
 
+    /** \brief mapping from suffix to queue index. */
+    map<suffix_id, u32> suffixes;
+
+    /** \brief Mapping from vertex to key, for vertices with a
+     * CHECK_NOT_HANDLED instruction. */
+    ue2::unordered_map<RoseVertex, u32> handledKeys;
+
     /** \brief Number of roles with a state bit.
-     * This set by buildInitialRoleTable() and should be constant throughout
+     *
+     * This is set by assignStateIndices() and should be constant throughout
      * the rest of the compile.
      */
     size_t numStates = 0;
 
-    // Very simple cache from sparse iter to offset, used when building up
-    // iterators in early misc.
+    /** \brief Very simple cache from sparse iter to offset, used when building
+     * up iterators in early misc. */
     map<vector<mmbit_sparse_iter>, u32> iterCache;
 
-    /** \brief maps RoseRole index to a list of RosePred indices */
-    map<u32, vector<u32> > rolePredecessors;
+    /** \brief Simple cache of programs written to engine blob, used for
+     * deduplication. */
+    ue2::unordered_map<vector<RoseInstruction>, u32> program_cache;
+
+    /** \brief LookEntry list cache, so that we don't have to go scanning
+     * through the full list to find cases we've used already. */
+    ue2::unordered_map<vector<LookEntry>, size_t> lookaround_cache;
 
     /** \brief Lookaround table for Rose roles. */
     vector<LookEntry> lookaround;
 
-    /** \brief Map from literal final ID to a set of non-root role IDs. */
-    ue2::unordered_map<u32, set<u32>> litNonRootRoles;
+    /** \brief State indices, for those roles that have them. */
+    ue2::unordered_map<RoseVertex, u32> roleStateIndices;
 
-    /* contents of rose immediately following the RoseEngine. */
-    vector<char> engine_blob;
+    /** \brief Mapping from queue index to bytecode offset for built engines
+     * that have already been pushed into the engine_blob. */
+    ue2::unordered_map<u32, u32> engineOffsets;
 
-    /* base offset of engine_blob in the bytecode */
-    const u32 engine_blob_base = ROUNDUP_16(sizeof(RoseEngine));
+    /** \brief Minimum offset of a match from the floating table. */
+    u32 floatingMinLiteralMatchOffset = 0;
+
+    /** \brief Contents of the Rose bytecode immediately following the
+     * RoseEngine. */
+    vector<char, AlignedAllocator<char, 64>> engine_blob;
+
+    /** \brief True if reports need CATCH_UP instructions, to catch up anchored
+     * matches, suffixes, outfixes etc. */
+    bool needs_catchup = false;
+
+    /** \brief True if this Rose engine has an MPV engine. */
+    bool needs_mpv_catchup = false;
+
+    /** \brief Resources in use (tracked as programs are added). */
+    RoseResources resources;
+
+    /** \brief Base offset of engine_blob in the Rose engine bytecode. */
+    static constexpr u32 engine_blob_base = ROUNDUP_CL(sizeof(RoseEngine));
 };
 
 }
 
-/* vertex ordered by their role index */
 static
-vector<RoseVertex> get_ordered_verts(const RoseGraph &g) {
-    vector<RoseVertex> verts;
-    insert(&verts, verts.end(), vertices_range(g));
-    sort(verts.begin(), verts.end(),
-         [&g](const RoseVertex &a, const RoseVertex &b) {
-             return g[a].role < g[b].role;
-         });
-    return verts;
+void pad_engine_blob(build_context &bc, size_t align) {
+    assert(ISALIGNED_N(bc.engine_blob_base, align));
+    size_t s = bc.engine_blob.size();
+
+    if (ISALIGNED_N(s, align)) {
+        return;
+    }
+
+    bc.engine_blob.resize(s + align - s % align);
+}
+
+static
+u32 add_to_engine_blob(build_context &bc, const void *a, const size_t len,
+                       const size_t align) {
+    pad_engine_blob(bc, align);
+
+    size_t rv = bc.engine_blob_base + bc.engine_blob.size();
+    assert(rv >= bc.engine_blob_base);
+    DEBUG_PRINTF("write %zu bytes at offset %zu\n", len, rv);
+
+    assert(ISALIGNED_N(bc.engine_blob.size(), align));
+
+    bc.engine_blob.resize(bc.engine_blob.size() + len);
+    memcpy(&bc.engine_blob.back() - len + 1, a, len);
+
+    return verify_u32(rv);
+}
+
+template<typename T>
+static
+u32 add_to_engine_blob(build_context &bc, const T &a) {
+    static_assert(is_pod<T>::value, "should be pod");
+    return add_to_engine_blob(bc, &a, sizeof(a), alignof(T));
+}
+
+template<typename T>
+static
+u32 add_to_engine_blob(build_context &bc, const T &a, const size_t len) {
+    static_assert(is_pod<T>::value, "should be pod");
+    return add_to_engine_blob(bc, &a, len, alignof(T));
+}
+
+template<typename Iter>
+static
+u32 add_to_engine_blob(build_context &bc, Iter b, const Iter &e) {
+    using value_type = typename Iter::value_type;
+    static_assert(is_pod<value_type>::value, "should be pod");
+
+    if (b == e) {
+        return 0;
+    }
+
+    u32 offset = add_to_engine_blob(bc, *b);
+    for (++b; b != e; ++b) {
+        add_to_engine_blob(bc, *b);
+    }
+
+    return offset;
+}
+
+static
+const NFA *get_nfa_from_blob(const build_context &bc, u32 qi) {
+    assert(contains(bc.engineOffsets, qi));
+    u32 nfa_offset = bc.engineOffsets.at(qi);
+    assert(nfa_offset >= bc.engine_blob_base);
+    const NFA *n = (const NFA *)(bc.engine_blob.data() + nfa_offset -
+                                 bc.engine_blob_base);
+    assert(n->queueIndex == qi);
+    return n;
+}
+
+static
+const NFA *add_nfa_to_blob(build_context &bc, NFA &nfa) {
+    u32 qi = nfa.queueIndex;
+    u32 nfa_offset = add_to_engine_blob(bc, nfa, nfa.length);
+    DEBUG_PRINTF("added nfa qi=%u, type=%u, length=%u at offset=%u\n", qi,
+                  nfa.type, nfa.length, nfa_offset);
+
+    assert(!contains(bc.engineOffsets, qi));
+    bc.engineOffsets.emplace(qi, nfa_offset);
+
+    const NFA *n = get_nfa_from_blob(bc, qi);
+    assert(memcmp(&nfa, n, nfa.length) == 0);
+    return n;
 }
 
 static
@@ -249,42 +512,74 @@ u32 countRosePrefixes(const vector<LeftNfaInfo> &roses) {
     return num;
 }
 
+/**
+ * \brief True if this Rose engine needs to run a catch up whenever a report is
+ * generated.
+ *
+ * This is only the case if there are no anchored literals, suffixes, outfixes
+ * etc.
+ */
 static
-bool isPureFloating(const RoseBuildImpl &tbi) {
-    if (!tbi.outfixes.empty()) {
+bool needsCatchup(const RoseBuildImpl &build) {
+    if (!build.outfixes.empty()) {
         DEBUG_PRINTF("has outfixes\n");
-        return false;
+        return true;
     }
 
-    const RoseGraph &g = tbi.g;
+    const RoseGraph &g = build.g;
 
-    if (!isLeafNode(tbi.anchored_root, g)) {
+    if (!isLeafNode(build.anchored_root, g)) {
         DEBUG_PRINTF("has anchored vertices\n");
-        return false;
+        return true;
     }
 
     for (auto v : vertices_range(g)) {
-        if (tbi.root == v) {
+        if (build.root == v) {
             continue;
         }
 
-        if (tbi.anchored_root == v) {
+        if (build.anchored_root == v) {
             assert(isLeafNode(v, g));
             continue;
         }
 
-        if (!tbi.hasDirectFinalId(v) || !tbi.isFloating(v)) {
-            DEBUG_PRINTF("vertex %zu isn't floating and direct\n", g[v].idx);
-            return false;
+        if (g[v].suffix) {
+            DEBUG_PRINTF("vertex %zu has suffix\n", g[v].idx);
+            return true;
         }
 
-        for (ReportID r : g[v].reports) {
-            const Report &ri = tbi.rm.getReport(r);
-            if (!isExternalReport(ri)) {
-                DEBUG_PRINTF("vertex %zu has non-external report\n", g[v].idx);
-                return false;
-            }
-        }
+    }
+
+    DEBUG_PRINTF("no need for catch-up on report\n");
+    return false;
+}
+
+static
+bool isPureFloating(const RoseResources &resources) {
+    if (resources.has_outfixes || resources.has_suffixes ||
+        resources.has_leftfixes) {
+        DEBUG_PRINTF("has engines\n");
+        return false;
+    }
+
+    if (resources.has_anchored) {
+        DEBUG_PRINTF("has anchored matcher\n");
+        return false;
+    }
+
+    if (resources.has_states) {
+        DEBUG_PRINTF("has states\n");
+        return false;
+    }
+
+    if (resources.has_lit_delay) {
+        DEBUG_PRINTF("has delayed literals\n");
+        return false;
+    }
+
+    if (resources.checks_groups) {
+        DEBUG_PRINTF("has group checks\n");
+        return false;
     }
 
     DEBUG_PRINTF("pure floating literals\n");
@@ -292,7 +587,7 @@ bool isPureFloating(const RoseBuildImpl &tbi) {
 }
 
 static
-bool isSingleOutfix(const RoseBuildImpl &tbi, u32 outfixEndQueue) {
+bool isSingleOutfix(const RoseBuildImpl &tbi) {
     for (auto v : vertices_range(tbi.g)) {
         if (tbi.isAnyStart(v)) {
             continue;
@@ -312,38 +607,73 @@ bool isSingleOutfix(const RoseBuildImpl &tbi, u32 outfixEndQueue) {
         return false; /* streaming runtime makes liberal use of broken flag */
     }
 
-    return outfixEndQueue == 1;
+    return tbi.outfixes.size() == 1;
 }
 
 static
-u8 pickRuntimeImpl(const RoseBuildImpl &tbi, u32 outfixEndQueue) {
-    if (isPureFloating(tbi)) {
+u8 pickRuntimeImpl(const RoseBuildImpl &build, const build_context &bc,
+                   UNUSED u32 outfixEndQueue) {
+    DEBUG_PRINTF("has_outfixes=%d\n", bc.resources.has_outfixes);
+    DEBUG_PRINTF("has_suffixes=%d\n", bc.resources.has_suffixes);
+    DEBUG_PRINTF("has_leftfixes=%d\n", bc.resources.has_leftfixes);
+    DEBUG_PRINTF("has_literals=%d\n", bc.resources.has_literals);
+    DEBUG_PRINTF("has_states=%d\n", bc.resources.has_states);
+    DEBUG_PRINTF("checks_groups=%d\n", bc.resources.checks_groups);
+    DEBUG_PRINTF("has_lit_delay=%d\n", bc.resources.has_lit_delay);
+    DEBUG_PRINTF("has_lit_mask=%d\n", bc.resources.has_lit_mask);
+    DEBUG_PRINTF("has_anchored=%d\n", bc.resources.has_anchored);
+
+    if (isPureFloating(bc.resources)) {
         return ROSE_RUNTIME_PURE_LITERAL;
     }
 
-    if (isSingleOutfix(tbi, outfixEndQueue)) {
+    if (isSingleOutfix(build)) {
         return ROSE_RUNTIME_SINGLE_OUTFIX;
     }
 
     return ROSE_RUNTIME_FULL_ROSE;
 }
 
+/**
+ * \brief True if this Rose engine needs to run MPV catch up in front of
+ * non-MPV reports.
+ */
 static
-void fillStateOffsets(const RoseBuildImpl &tbi, const sidecar *side,
-                      u32 rolesWithStateCount, u32 anchorStateSize,
-                      u32 activeArrayCount, u32 activeLeftCount,
-                      u32 laggedRoseCount, u32 floatingStreamStateRequired,
-                      u32 historyRequired, RoseStateOffsets *so) {
-    /* runtime state (including role state) first and needs to be u32-aligned */
-    u32 curr_offset = sizeof(RoseRuntimeState)
-                    + mmbit_size(rolesWithStateCount);
+bool needsMpvCatchup(const RoseBuildImpl &build) {
+    const auto &outfixes = build.outfixes;
+    bool has_mpv =
+        any_of(begin(outfixes), end(outfixes), [](const OutfixInfo &outfix) {
+            return outfix.is_nonempty_mpv();
+        });
 
-    so->sidecar = curr_offset;
-    if (side) {
-        so->sidecar_size = sidecarEnabledSize(side);
-        curr_offset += so->sidecar_size;
+    if (!has_mpv) {
+        DEBUG_PRINTF("no mpv\n");
+        return false;
     }
 
+    if (isSingleOutfix(build)) {
+        DEBUG_PRINTF("single outfix\n");
+        return false;
+    }
+
+    return true;
+}
+
+static
+void fillStateOffsets(const RoseBuildImpl &tbi, u32 rolesWithStateCount,
+                      u32 anchorStateSize, u32 activeArrayCount,
+                      u32 activeLeftCount, u32 laggedRoseCount,
+                      u32 floatingStreamStateRequired, u32 historyRequired,
+                      RoseStateOffsets *so) {
+    u32 curr_offset = 0;
+
+    // First, runtime status (stores per-stream state, like whether we need a
+    // delay rebuild or have been told to halt matching.)
+    curr_offset += sizeof(u8);
+
+    // Role state storage.
+    curr_offset += mmbit_size(rolesWithStateCount);
+
     so->activeLeafArray = curr_offset; /* TODO: limit size of array */
     curr_offset += mmbit_size(activeArrayCount);
 
@@ -358,11 +688,6 @@ void fillStateOffsets(const RoseBuildImpl &tbi, const sidecar *side,
     so->leftfixLagTable = curr_offset;
     curr_offset += laggedRoseCount;
 
-    // Anchored state is McClellan full state, and needs to be 2-byte aligned.
-    // We potentially waste a byte here.
-    if (curr_offset % 2) {
-        curr_offset++;
-    }
     so->anchorState = curr_offset;
     curr_offset += anchorStateSize;
 
@@ -375,9 +700,9 @@ void fillStateOffsets(const RoseBuildImpl &tbi, const sidecar *side,
     so->history = curr_offset;
     curr_offset += historyRequired;
 
-    // Exhausted bit vector.
+    // Exhaustion multibit.
     so->exhausted = curr_offset;
-    curr_offset += ROUNDUP_N(tbi.rm.numEkeys(), 8) / 8;
+    curr_offset += mmbit_size(tbi.rm.numEkeys());
 
     // SOM locations and valid/writeable multibit structures.
     if (tbi.ssm.numSomSlots()) {
@@ -541,14 +866,14 @@ static
 aligned_unique_ptr<NFA>
 buildRepeatEngine(const CastleProto &proto,
                   const map<u32, vector<vector<CharReach>>> &triggers,
-                  const CompileContext &cc) {
+                  const CompileContext &cc, const ReportManager &rm) {
     // If we only have one repeat, the LBR should always be the best possible
     // implementation.
     if (proto.repeats.size() == 1 && cc.grey.allowLbr) {
-        return constructLBR(proto.repeats.begin()->second, triggers.at(0), cc);
+        return constructLBR(proto, triggers.at(0), cc, rm);
     }
 
-    aligned_unique_ptr<NFA> castle_nfa = buildCastle(proto, triggers, cc);
+    auto castle_nfa = buildCastle(proto, triggers, cc, rm);
     assert(castle_nfa); // Should always be constructible.
     return castle_nfa;
 }
@@ -561,19 +886,19 @@ buildSuffix(const ReportManager &rm, const SomSlotManager &ssm,
             const map<u32, vector<vector<CharReach>>> &triggers,
             suffix_id suff, const CompileContext &cc) {
     if (suff.castle()) {
-        auto n = buildRepeatEngine(*suff.castle(), triggers, cc);
+        auto n = buildRepeatEngine(*suff.castle(), triggers, cc, rm);
         assert(n);
         return n;
     }
 
     if (suff.haig()) {
-        auto n = goughCompile(*suff.haig(), ssm.somPrecision(), cc);
+        auto n = goughCompile(*suff.haig(), ssm.somPrecision(), cc, rm);
         assert(n);
         return n;
     }
 
     if (suff.dfa()) {
-        auto d = mcclellanCompile(*suff.dfa(), cc);
+        auto d = mcclellanCompile(*suff.dfa(), cc, rm);
         assert(d);
         return d;
     }
@@ -586,7 +911,7 @@ buildSuffix(const ReportManager &rm, const SomSlotManager &ssm,
 
     // Take a shot at the LBR engine.
     if (oneTop) {
-        auto lbr = constructLBR(holder, triggers.at(0), cc);
+        auto lbr = constructLBR(holder, triggers.at(0), cc, rm);
         if (lbr) {
             return lbr;
         }
@@ -602,7 +927,7 @@ buildSuffix(const ReportManager &rm, const SomSlotManager &ssm,
             auto rdfa = buildMcClellan(holder, &rm, false, triggers.at(0),
                                        cc.grey);
             if (rdfa) {
-                auto d = mcclellanCompile(*rdfa, cc);
+                auto d = mcclellanCompile(*rdfa, cc, rm);
                 assert(d);
                 if (cc.grey.roseMcClellanSuffix != 2) {
                     n = pickImpl(move(d), move(n));
@@ -689,6 +1014,8 @@ makeLeftNfa(const RoseBuildImpl &tbi, left_id &left,
             const bool is_prefix, const bool is_transient,
             const map<left_id, set<PredTopPair> > &infixTriggers,
             const CompileContext &cc) {
+    const ReportManager &rm = tbi.rm;
+
     aligned_unique_ptr<NFA> n;
 
     // Should compress state if this rose is non-transient and we're in
@@ -713,18 +1040,18 @@ makeLeftNfa(const RoseBuildImpl &tbi, left_id &left,
         assert(!is_prefix);
         map<u32, vector<vector<CharReach> > > triggers;
         findTriggerSequences(tbi, infixTriggers.at(left), &triggers);
-        n = buildRepeatEngine(*left.castle(), triggers, cc);
+        n = buildRepeatEngine(*left.castle(), triggers, cc, rm);
         assert(n);
         return n; // Castles/LBRs are always best!
     }
 
     if (left.dfa()) {
-        n = mcclellanCompile(*left.dfa(), cc);
+        n = mcclellanCompile(*left.dfa(), cc, rm);
     } else if (left.graph() && cc.grey.roseMcClellanPrefix == 2 && is_prefix &&
                !is_transient) {
         auto rdfa = buildMcClellan(*left.graph(), nullptr, cc.grey);
         if (rdfa) {
-            n = mcclellanCompile(*rdfa, cc);
+            n = mcclellanCompile(*rdfa, cc, rm);
         }
     }
 
@@ -733,7 +1060,7 @@ makeLeftNfa(const RoseBuildImpl &tbi, left_id &left,
         map<u32, vector<vector<CharReach> > > triggers;
         findTriggerSequences(tbi, infixTriggers.at(left), &triggers);
         assert(contains(triggers, 0)); // single top
-        n = constructLBR(*left.graph(), triggers[0], cc);
+        n = constructLBR(*left.graph(), triggers[0], cc, rm);
     }
 
     if (!n && left.graph()) {
@@ -748,7 +1075,7 @@ makeLeftNfa(const RoseBuildImpl &tbi, left_id &left,
         && (!n || !has_bounded_repeats_other_than_firsts(*n) || !is_fast(*n))) {
         auto rdfa = buildMcClellan(*left.graph(), nullptr, cc.grey);
         if (rdfa) {
-            auto d = mcclellanCompile(*rdfa, cc);
+            auto d = mcclellanCompile(*rdfa, cc, rm);
             assert(d);
             n = pickImpl(move(d), move(n));
         }
@@ -775,15 +1102,14 @@ void setLeftNfaProperties(NFA &n, const left_id &left) {
 }
 
 static
-bool buildLeftfixes(const RoseBuildImpl &tbi, QueueIndexFactory &qif,
-                    vector<aligned_unique_ptr<NFA>> *built_out,
-                    set<u32> *no_retrigger_queues,
-                    map<RoseVertex, left_build_info> *leftfix_info,
+bool buildLeftfixes(const RoseBuildImpl &tbi, build_context &bc,
+                    QueueIndexFactory &qif, set<u32> *no_retrigger_queues,
                     bool do_prefix) {
     const RoseGraph &g = tbi.g;
     const CompileContext &cc = tbi.cc;
+    const ReportManager &rm = tbi.rm;
 
-    ue2::unordered_map<left_id, NFA *> seen;
+    ue2::unordered_map<left_id, u32> seen; // already built queue indices
 
     map<left_id, set<PredTopPair> > infixTriggers;
     findInfixTriggers(tbi, &infixTriggers);
@@ -806,7 +1132,6 @@ bool buildLeftfixes(const RoseBuildImpl &tbi, QueueIndexFactory &qif,
         // our in-edges.
         assert(roseHasTops(g, v));
 
-        NFA *n;
         u32 qi; // queue index, set below.
         u32 lag = g[v].left.lag;
         bool is_transient = contains(tbi.transient, leftfix);
@@ -815,16 +1140,15 @@ bool buildLeftfixes(const RoseBuildImpl &tbi, QueueIndexFactory &qif,
             vector<LookEntry> lookaround;
             if (makeLeftfixLookaround(tbi, v, lookaround)) {
                 DEBUG_PRINTF("implementing as lookaround!\n");
-                leftfix_info->emplace(v, left_build_info(lookaround));
+                bc.leftfix_info.emplace(v, left_build_info(lookaround));
                 continue;
             }
         }
 
         if (contains(seen, leftfix)) {
             // NFA already built.
-            n = seen[leftfix];
-            qi = n->queueIndex;
-            assert(qi < built_out->size());
+            qi = seen[leftfix];
+            assert(contains(bc.engineOffsets, qi));
             DEBUG_PRINTF("sharing leftfix, qi=%u\n", qi);
         } else {
             DEBUG_PRINTF("making %sleftfix\n", is_transient ? "transient " : "");
@@ -834,7 +1158,8 @@ bool buildLeftfixes(const RoseBuildImpl &tbi, QueueIndexFactory &qif,
             // Need to build NFA, which is either predestined to be a Haig (in
             // SOM mode) or could be all manner of things.
             if (leftfix.haig()) {
-                nfa = goughCompile(*leftfix.haig(), tbi.ssm.somPrecision(), cc);
+                nfa = goughCompile(*leftfix.haig(), tbi.ssm.somPrecision(), cc,
+                                   rm);
             }  else {
                 assert(tbi.isNonRootSuccessor(v) != tbi.isRootSuccessor(v));
                 nfa = makeLeftNfa(tbi, leftfix, is_prefix, is_transient,
@@ -849,7 +1174,6 @@ bool buildLeftfixes(const RoseBuildImpl &tbi, QueueIndexFactory &qif,
             setLeftNfaProperties(*nfa, leftfix);
 
             qi = qif.get_queue();
-            assert(qi == built_out->size());
             nfa->queueIndex = qi;
 
             if (!is_prefix && !leftfix.haig() && leftfix.graph() &&
@@ -858,10 +1182,9 @@ bool buildLeftfixes(const RoseBuildImpl &tbi, QueueIndexFactory &qif,
                 no_retrigger_queues->insert(qi);
             }
 
-            n = nfa.get();
-            seen.insert(make_pair(leftfix, n));
             DEBUG_PRINTF("built leftfix, qi=%u\n", qi);
-            built_out->push_back(move(nfa));
+            add_nfa_to_blob(bc, *nfa);
+            seen.emplace(leftfix, qi);
         }
 
         rose_group squash_mask = tbi.rose_squash_masks.at(leftfix);
@@ -907,10 +1230,9 @@ bool buildLeftfixes(const RoseBuildImpl &tbi, QueueIndexFactory &qif,
             findCountingMiracleInfo(leftfix, stop, &cm_count, &cm_cr);
         }
 
-        leftfix_info->insert(
-                make_pair(v, left_build_info(n, qi, lag, max_width,
-                                             squash_mask, stop, max_queuelen,
-                                             cm_count, cm_cr)));
+        bc.leftfix_info.emplace(
+            v, left_build_info(qi, lag, max_width, squash_mask, stop,
+                               max_queuelen, cm_count, cm_cr));
     }
 
     return true;
@@ -939,92 +1261,112 @@ bool hasNonSmallBlockOutfix(const vector<OutfixInfo> &outfixes) {
     return false;
 }
 
-static
-aligned_unique_ptr<NFA> buildOutfix(RoseBuildImpl &tbi, OutfixInfo &outfix) {
-    assert(!outfix.is_dead()); // should not be marked dead.
-    assert(!outfix.nfa); // should not be already built.
+namespace {
+class OutfixBuilder : public boost::static_visitor<aligned_unique_ptr<NFA>> {
+public:
+    explicit OutfixBuilder(const RoseBuildImpl &build_in) : build(build_in) {}
 
-    const CompileContext &cc = tbi.cc;
-    const ReportManager &rm = tbi.rm;
+    aligned_unique_ptr<NFA> operator()(boost::blank&) const {
+        return nullptr;
+    };
 
-    aligned_unique_ptr<NFA> n;
-    if (outfix.rdfa) {
+    aligned_unique_ptr<NFA> operator()(unique_ptr<raw_dfa> &rdfa) const {
         // Unleash the McClellan!
-        n = mcclellanCompile(*outfix.rdfa, cc);
-    } else if (outfix.haig) {
+        return mcclellanCompile(*rdfa, build.cc, build.rm);
+    }
+
+    aligned_unique_ptr<NFA> operator()(unique_ptr<raw_som_dfa> &haig) const {
         // Unleash the Goughfish!
-        n = goughCompile(*outfix.haig, tbi.ssm.somPrecision(), cc);
-    } else if (outfix.holder) {
-        NGHolder &h = *outfix.holder;
+        return goughCompile(*haig, build.ssm.somPrecision(), build.cc,
+                            build.rm);
+    }
+
+    aligned_unique_ptr<NFA> operator()(unique_ptr<NGHolder> &holder) const {
+        const CompileContext &cc = build.cc;
+        const ReportManager &rm = build.rm;
+
+        NGHolder &h = *holder;
         assert(h.kind == NFA_OUTFIX);
 
         // Build NFA.
-        if (!n) {
-            const map<u32, u32> fixed_depth_tops; /* no tops */
-            const map<u32, vector<vector<CharReach>>> triggers; /* no tops */
-            bool compress_state = cc.streaming;
-            n = constructNFA(h, &rm, fixed_depth_tops, triggers, compress_state,
-                             cc);
-        }
+        const map<u32, u32> fixed_depth_tops; /* no tops */
+        const map<u32, vector<vector<CharReach>>> triggers; /* no tops */
+        bool compress_state = cc.streaming;
+        auto n = constructNFA(h, &rm, fixed_depth_tops, triggers,
+                              compress_state, cc);
 
         // Try for a DFA upgrade.
-        if (n && cc.grey.roseMcClellanOutfix
-            && !has_bounded_repeats_other_than_firsts(*n)) {
+        if (n && cc.grey.roseMcClellanOutfix &&
+            !has_bounded_repeats_other_than_firsts(*n)) {
             auto rdfa = buildMcClellan(h, &rm, cc.grey);
             if (rdfa) {
-                auto d = mcclellanCompile(*rdfa, cc);
+                auto d = mcclellanCompile(*rdfa, cc, rm);
                 if (d) {
                     n = pickImpl(move(d), move(n));
                 }
             }
         }
-    } else if (!outfix.puffettes.empty()) {
-        assert(0);
+
+        return n;
     }
 
-    if (n && tbi.cc.grey.reverseAccelerate) {
+    aligned_unique_ptr<NFA> operator()(UNUSED MpvProto &mpv) const {
+        // MPV construction handled separately.
+        assert(mpv.puffettes.empty());
+        return nullptr;
+    }
+
+private:
+    const RoseBuildImpl &build;
+};
+}
+
+static
+aligned_unique_ptr<NFA> buildOutfix(RoseBuildImpl &build, OutfixInfo &outfix) {
+    assert(!outfix.is_dead()); // should not be marked dead.
+
+    auto n = boost::apply_visitor(OutfixBuilder(build), outfix.proto);
+    if (n && build.cc.grey.reverseAccelerate) {
         buildReverseAcceleration(n.get(), outfix.rev_info, outfix.minWidth);
     }
 
-    outfix.nfa = n.get();
     return n;
 }
 
 static
-void prepMpv(RoseBuildImpl &tbi, vector<aligned_unique_ptr<NFA>> *built_nfas,
-             size_t *historyRequired, bool *mpv_as_outfix) {
-    assert(built_nfas->empty());
+void prepMpv(RoseBuildImpl &tbi, build_context &bc, size_t *historyRequired,
+             bool *mpv_as_outfix) {
+    assert(bc.engineOffsets.empty()); // MPV should be first
     *mpv_as_outfix = false;
-    OutfixInfo *mpv = nullptr;
+    OutfixInfo *mpv_outfix = nullptr;
 
     /* assume outfixes are just above chain tails in queue indices */
     for (auto &out : tbi.outfixes) {
         if (out.is_nonempty_mpv()) {
-            assert(!mpv);
-            mpv = &out;
+            assert(!mpv_outfix);
+            mpv_outfix = &out;
         } else {
-            assert(!out.chained);
+            assert(!out.mpv());
         }
     }
 
-    if (!mpv) {
+    if (!mpv_outfix) {
         return;
     }
 
-    assert(mpv->chained);
-    assert(!mpv->nfa);
-    auto nfa = mpvCompile(mpv->puffettes, mpv->triggered_puffettes);
+    auto *mpv = mpv_outfix->mpv();
+    auto nfa = mpvCompile(mpv->puffettes, mpv->triggered_puffettes, tbi.rm);
     assert(nfa);
     if (!nfa) {
         throw CompileError("Unable to generate bytecode.");
     }
 
     if (tbi.cc.grey.reverseAccelerate) {
-        buildReverseAcceleration(nfa.get(), mpv->rev_info, mpv->minWidth);
+        buildReverseAcceleration(nfa.get(), mpv_outfix->rev_info,
+                                 mpv_outfix->minWidth);
     }
 
-    u32 qi = mpv->get_queue(tbi.qif);
-    assert(qi == built_nfas->size());
+    u32 qi = mpv_outfix->get_queue(tbi.qif);
     nfa->queueIndex = qi;
 
     DEBUG_PRINTF("built mpv\n");
@@ -1033,8 +1375,7 @@ void prepMpv(RoseBuildImpl &tbi, vector<aligned_unique_ptr<NFA>> *built_nfas,
         *historyRequired = 1;
     }
 
-    mpv->nfa = nfa.get();
-    built_nfas->push_back(move(nfa));
+    add_nfa_to_blob(bc, *nfa);
     *mpv_as_outfix = !mpv->puffettes.empty();
 }
 
@@ -1061,8 +1402,7 @@ void setOutfixProperties(NFA &n, const OutfixInfo &outfix) {
 }
 
 static
-bool prepOutfixes(RoseBuildImpl &tbi,
-                  vector<aligned_unique_ptr<NFA>> *built_nfas,
+bool prepOutfixes(RoseBuildImpl &tbi, build_context &bc,
                   size_t *historyRequired) {
     if (tbi.cc.grey.onlyOneOutfix && tbi.outfixes.size() > 1) {
         DEBUG_PRINTF("we have %zu outfixes, but Grey::onlyOneOutfix is set\n",
@@ -1070,16 +1410,13 @@ bool prepOutfixes(RoseBuildImpl &tbi,
         throw ResourceLimitError();
     }
 
-    assert(tbi.qif.allocated_count() == built_nfas->size());
-    /* assume outfixes are just above chain tails in queue indices */
-    built_nfas->reserve(tbi.outfixes.size());
+    assert(tbi.qif.allocated_count() == bc.engineOffsets.size());
 
     for (auto &out : tbi.outfixes) {
-        if (out.chained) {
+        if (out.mpv()) {
             continue; /* already done */
         }
-        DEBUG_PRINTF("building outfix %zd (holder %p rdfa %p)\n",
-                     &out - &tbi.outfixes[0], out.holder.get(), out.rdfa.get());
+        DEBUG_PRINTF("building outfix %zd\n", &out - &tbi.outfixes[0]);
         auto n = buildOutfix(tbi, out);
         if (!n) {
             assert(0);
@@ -1088,24 +1425,21 @@ bool prepOutfixes(RoseBuildImpl &tbi,
 
         setOutfixProperties(*n, out);
 
-        u32 qi = tbi.qif.get_queue();
-        assert(qi == built_nfas->size());
-        n->queueIndex = qi;
+        n->queueIndex = out.get_queue(tbi.qif);
 
         if (!*historyRequired && requires_decompress_key(*n)) {
             *historyRequired = 1;
         }
 
-        built_nfas->push_back(move(n));
+        add_nfa_to_blob(bc, *n);
     }
 
     return true;
 }
 
 static
-void findSuffixes(const RoseBuildImpl &tbi, QueueIndexFactory &qif,
-                  map<suffix_id, u32> *suffixes) {
-    const RoseGraph &g = tbi.g;
+void assignSuffixQueues(RoseBuildImpl &build, build_context &bc) {
+    const RoseGraph &g = build.g;
 
     for (auto v : vertices_range(g)) {
         if (!g[v].suffix) {
@@ -1117,13 +1451,13 @@ void findSuffixes(const RoseBuildImpl &tbi, QueueIndexFactory &qif,
         DEBUG_PRINTF("vertex %zu triggers suffix %p\n", g[v].idx, s.graph());
 
         // We may have already built this NFA.
-        if (contains(*suffixes, s)) {
+        if (contains(bc.suffixes, s)) {
             continue;
         }
 
-        u32 queue = qif.get_queue();
+        u32 queue = build.qif.get_queue();
         DEBUG_PRINTF("assigning %p to queue %u\n", s.graph(), queue);
-        suffixes->insert(make_pair(s, queue));
+        bc.suffixes.emplace(s, queue);
     }
 }
 
@@ -1147,16 +1481,23 @@ void setSuffixProperties(NFA &n, const suffix_id &suff,
 }
 
 static
-bool buildSuffixes(const RoseBuildImpl &tbi,
-                   vector<aligned_unique_ptr<NFA>> *built_nfas,
-                   map<suffix_id, u32> *suffixes,
+bool buildSuffixes(const RoseBuildImpl &tbi, build_context &bc,
                    set<u32> *no_retrigger_queues) {
     map<suffix_id, set<PredTopPair> > suffixTriggers;
     findSuffixTriggers(tbi, &suffixTriggers);
 
-    for (const auto &e : *suffixes) {
-        const suffix_id &s = e.first;
-        const u32 queue = e.second;
+    // To ensure compile determinism, build suffix engines in order of their
+    // (unique) queue indices, so that we call add_nfa_to_blob in the same
+    // order.
+    vector<pair<u32, suffix_id>> ordered;
+    for (const auto &e : bc.suffixes) {
+        ordered.emplace_back(e.second, e.first);
+    }
+    sort(begin(ordered), end(ordered));
+
+    for (const auto &e : ordered) {
+        const u32 queue = e.first;
+        const suffix_id &s = e.second;
         const set<PredTopPair> &s_triggers = suffixTriggers.at(s);
 
         map<u32, u32> fixed_depth_tops;
@@ -1181,69 +1522,12 @@ bool buildSuffixes(const RoseBuildImpl &tbi,
             no_retrigger_queues->insert(queue);
         }
 
-        if (built_nfas->size() <= queue) {
-            built_nfas->resize(queue + 1);
-        }
-
-        (*built_nfas)[queue] = move(n);
+        add_nfa_to_blob(bc, *n);
     }
 
     return true;
 }
 
-static
-void pad_engine_blob(build_context &bc, size_t align) {
-    assert(ISALIGNED_N(bc.engine_blob_base, align));
-    size_t s = bc.engine_blob.size();
-
-    if (ISALIGNED_N(s, align)) {
-        return;
-    }
-
-    bc.engine_blob.resize(s + align - s % align);
-}
-
-template<typename T>
-static
-u32 add_to_engine_blob(build_context &bc, const T &a) {
-    static_assert(is_pod<T>::value, "should be pod");
-    pad_engine_blob(bc, alignof(T));
-
-    size_t rv = bc.engine_blob_base + bc.engine_blob.size();
-    assert(rv >= bc.engine_blob_base);
-
-    assert(ISALIGNED_N(bc.engine_blob.size(), alignof(T)));
-
-    bc.engine_blob.resize(bc.engine_blob.size() + sizeof(a));
-    memcpy(&bc.engine_blob.back() - sizeof(a) + 1, &a, sizeof(a));
-
-    return verify_u32(rv);
-}
-
-template<typename Iter>
-static
-u32 add_to_engine_blob(build_context &bc, Iter b, const Iter &e) {
-    using value_type = typename Iter::value_type;
-    static_assert(is_pod<value_type>::value, "should be pod");
-    pad_engine_blob(bc, alignof(value_type));
-
-    size_t rv = bc.engine_blob_base + bc.engine_blob.size();
-    assert(rv >= bc.engine_blob_base);
-
-    assert(ISALIGNED_N(bc.engine_blob.size(), alignof(value_type)));
-
-    size_t total_added_length = sizeof(*b) * distance(b, e);
-    bc.engine_blob.resize(bc.engine_blob.size() + total_added_length);
-    char *p = bc.engine_blob.data() + bc.engine_blob.size()
-            - total_added_length;
-    for (; b != e; ++b, p += sizeof(*b)) {
-        memcpy(p, &*b, sizeof(*b));
-    }
-    assert(p - 1 == &bc.engine_blob.back());
-
-    return verify_u32(rv);
-}
-
 static
 void buildCountingMiracles(RoseBuildImpl &build, build_context &bc) {
     map<pair<CharReach, u8>, u32> pre_built;
@@ -1300,26 +1584,21 @@ void buildCountingMiracles(RoseBuildImpl &build, build_context &bc) {
 }
 
 static
-bool buildNfas(RoseBuildImpl &tbi, QueueIndexFactory &qif,
-               vector<aligned_unique_ptr<NFA>> *built_nfas,
-               map<suffix_id, u32> *suffixes,
-               map<RoseVertex, left_build_info> *leftfix_info,
+bool buildNfas(RoseBuildImpl &tbi, build_context &bc, QueueIndexFactory &qif,
                set<u32> *no_retrigger_queues, u32 *leftfixBeginQueue) {
-    findSuffixes(tbi, qif, suffixes);
+    assignSuffixQueues(tbi, bc);
 
-    if (!buildSuffixes(tbi, built_nfas, suffixes, no_retrigger_queues)) {
+    if (!buildSuffixes(tbi, bc, no_retrigger_queues)) {
         return false;
     }
 
     *leftfixBeginQueue = qif.allocated_count();
 
-    if (!buildLeftfixes(tbi, qif, built_nfas, no_retrigger_queues, leftfix_info,
-                        true)) {
+    if (!buildLeftfixes(tbi, bc, qif, no_retrigger_queues, true)) {
         return false;
     }
 
-    if (!buildLeftfixes(tbi, qif, built_nfas, no_retrigger_queues, leftfix_info,
-                        false)) {
+    if (!buildLeftfixes(tbi, bc, qif, no_retrigger_queues, false)) {
         return false;
     }
 
@@ -1372,45 +1651,20 @@ void findTransientQueues(const map<RoseVertex, left_build_info> &leftfix_info,
 }
 
 static
-void updateNfaState(const vector<aligned_unique_ptr<NFA>> &built_nfas,
-                    const map<RoseVertex, left_build_info> &leftfix_info,
-                    RoseStateOffsets *so, NfaInfo *nfa_infos,
-                    u32 *fullStateSize, u32 *nfaStateSize, u32 *tStateSize) {
+void updateNfaState(const build_context &bc, RoseStateOffsets *so,
+                    NfaInfo *nfa_infos, u32 *fullStateSize, u32 *nfaStateSize,
+                    u32 *tStateSize) {
     *nfaStateSize = 0;
     *tStateSize = 0;
     *fullStateSize = 0;
 
     set<u32> transient_queues;
-    findTransientQueues(leftfix_info, &transient_queues);
+    findTransientQueues(bc.leftfix_info, &transient_queues);
 
-    for (const auto &n : built_nfas) {
-        allocateStateSpace(n.get(), transient_queues, so, nfa_infos,
-                           fullStateSize, nfaStateSize, tStateSize);
-    }
-}
-
-static
-void buildLitBenefits(const RoseBuildImpl &tbi, RoseEngine *engine,
-                      u32 base_lits_benefits_offset) {
-    lit_benefits *lba = (lit_benefits *)((char *)engine
-                                         + base_lits_benefits_offset);
-    DEBUG_PRINTF("base offset %u\n", base_lits_benefits_offset);
-    for (u32 i = 0; i < tbi.nonbenefits_base_id; i++) {
-        assert(contains(tbi.final_id_to_literal, i));
-        assert(tbi.final_id_to_literal.at(i).size() == 1);
-        u32 lit_id = *tbi.final_id_to_literal.at(i).begin();
-        const ue2_literal &s = tbi.literals.right.at(lit_id).s;
-        DEBUG_PRINTF("building mask for lit %u (fid %u) %s\n", lit_id, i,
-                     dumpString(s).c_str());
-        assert(s.length() <= MAX_MASK2_WIDTH);
-        u32 j = 0;
-        for (const auto &e : s) {
-            lba[i].and_mask.a8[j] = e.nocase ? 0 : CASE_BIT;
-            lba[i].expected.e8[j] = e.nocase ? 0 : (CASE_BIT & e.c);
-            DEBUG_PRINTF("a%02hhx e%02hhx\n", lba[i].and_mask.a8[j],
-                         lba[i].expected.e8[j]);
-            j++;
-        }
+    for (const auto &m : bc.engineOffsets) {
+        const NFA *n = get_nfa_from_blob(bc, m.first);
+        allocateStateSpace(n, transient_queues, so, nfa_infos, fullStateSize,
+                           nfaStateSize, tStateSize);
     }
 }
 
@@ -1478,733 +1732,6 @@ u32 RoseBuildImpl::calcHistoryRequired() const {
     return m ? m - 1 : 0;
 }
 
-static
-u32 sizeSideSuccMasks(const sidecar *stable,
-                      const map<set<u32>, set<RoseVertex> > &side_succ_map) {
-    if (!stable) {
-        return 0;
-    }
-
-    return verify_u32((side_succ_map.size() + 1 /* for init */)
-                      * sidecarEnabledSize(stable));
-}
-
-static
-void populateSideSuccLists(const RoseBuildImpl &tbi, build_context &bc,
-        const sidecar *stable, RoseEngine *engine, u32 base_offset,
-        const map<set<u32>, set<RoseVertex> > &sidecar_succ_map) {
-    const RoseGraph &g = tbi.g;
-
-    if (!stable) {
-        return;
-    }
-
-    u32 enabled_size = sidecarEnabledSize(stable);
-    char *curr = (char *)engine + base_offset;
-
-    for (const auto &e : sidecar_succ_map) {
-        u32 offset = verify_u32(curr - (char *)engine);
-
-        memset(curr, 0, enabled_size);
-        /* populate the list */
-        for (u32 side_id : e.first) {
-            sidecarEnabledAdd(stable, (sidecar_enabled *)curr, side_id);
-        }
-
-        curr += enabled_size;
-
-        /* update the role entries */
-        for (RoseVertex v : e.second) {
-            if (v == tbi.root) {
-                DEBUG_PRINTF("setting root emask\n");
-                engine->initSideEnableOffset = offset;
-            } else {
-                DEBUG_PRINTF("setting boring emask\n");
-                assert(g[v].role < bc.roleTable.size());
-                bc.roleTable[g[v].role].sidecarEnableOffset = offset;
-            }
-        }
-    }
-
-    if (!engine->initSideEnableOffset) {
-        DEBUG_PRINTF("add a blank enabled for root\n");
-        engine->initSideEnableOffset = verify_u32(curr - (char *)engine);
-        memset(curr, 0, enabled_size);
-        curr += enabled_size;
-    }
-}
-
-/* Also creates a map of sidecar id set to the roles which enables that set
- */
-static
-void markSideEnablers(RoseBuildImpl &build,
-                      map<set<u32>, set<RoseVertex> > *scmap) {
-    map<RoseVertex, set<u32> > enablers;
-    u32 side_id = 0;
-    for (const auto &e : build.side_squash_roles) {
-        for (RoseVertex v : e.second) {
-            enablers[v].insert(side_id);
-        }
-
-        side_id++;
-    }
-
-    for (const auto &e : enablers) {
-        (*scmap)[e.second].insert(e.first);
-    }
-}
-
-#ifdef DEBUG
-static UNUSED
-string dumpMask(const vector<u8> &v) {
-    ostringstream oss;
-    for (u8 e : v) {
-        oss << setfill('0') << setw(2) << hex << (unsigned int)e;
-    }
-    return oss.str();
-}
-#endif
-
-static
-bool maskFromLeftGraph(const LeftEngInfo &left, vector<u8> &msk,
-                       vector<u8> &cmp) {
-    const u32 lag = left.lag;
-    const ReportID report = left.leftfix_report;
-
-    DEBUG_PRINTF("leftfix with lag %u, report %u\n", lag, report);
-
-    assert(left.graph);
-    const NGHolder &h = *left.graph;
-    assert(in_degree(h.acceptEod, h) == 1); // no eod reports
-
-    // Start with the set of reporter vertices for this leftfix.
-    set<NFAVertex> curr;
-    for (auto u : inv_adjacent_vertices_range(h.accept, h)) {
-        if (contains(h[u].reports, report)) {
-            curr.insert(u);
-        }
-    }
-    assert(!curr.empty());
-
-    size_t i = HWLM_MASKLEN - lag - 1;
-    do {
-        if (curr.empty() || contains(curr, h.start)
-            || contains(curr, h.startDs)) {
-            DEBUG_PRINTF("end of the road\n");
-            break;
-        }
-
-        set<NFAVertex> next;
-        CharReach cr;
-        for (NFAVertex v : curr) {
-            const auto &v_cr = h[v].char_reach;
-            DEBUG_PRINTF("vertex %u, reach %s\n", h[v].index,
-                         describeClass(v_cr).c_str());
-            cr |= v_cr;
-            insert(&next, inv_adjacent_vertices(v, h));
-        }
-        make_and_cmp_mask(cr, &msk.at(i), &cmp.at(i));
-        DEBUG_PRINTF("%zu: reach=%s, msk=%u, cmp=%u\n", i,
-                     describeClass(cr).c_str(), msk[i], cmp[i]);
-        curr.swap(next);
-    } while (i-- > 0);
-
-    return true;
-}
-
-static
-bool maskFromLeftCastle(const LeftEngInfo &left, vector<u8> &msk,
-                        vector<u8> &cmp) {
-    const u32 lag = left.lag;
-    const ReportID report = left.leftfix_report;
-
-    DEBUG_PRINTF("leftfix with lag %u, report %u\n", lag, report);
-
-    assert(left.castle);
-    const CastleProto &c = *left.castle;
-
-    depth min_width(depth::infinity());
-    for (const PureRepeat &repeat : c.repeats | map_values) {
-        if (contains(repeat.reports, report)) {
-            min_width = min(min_width, repeat.bounds.min);
-        }
-    }
-
-    DEBUG_PRINTF("castle min width for this report is %s\n",
-                 min_width.str().c_str());
-
-    if (!min_width.is_finite() || min_width == depth(0)) {
-        DEBUG_PRINTF("bad min width\n");
-        return false;
-    }
-
-    u32 len = min_width;
-    u32 end = HWLM_MASKLEN - lag;
-    for (u32 i = end; i > end - min(end, len); i--) {
-        make_and_cmp_mask(c.reach(), &msk.at(i - 1), &cmp.at(i - 1));
-    }
-
-    return true;
-}
-
-static
-bool maskFromLeft(const LeftEngInfo &left, vector<u8> &msk, vector<u8> &cmp) {
-    if (left.lag >= HWLM_MASKLEN) {
-        DEBUG_PRINTF("too much lag\n");
-        return false;
-    }
-
-    if (left.graph) {
-        return maskFromLeftGraph(left, msk, cmp);
-    } else if (left.castle) {
-        return maskFromLeftCastle(left, msk, cmp);
-    }
-
-    return false;
-}
-
-static
-bool maskFromPreds(const RoseBuildImpl &tbi, const rose_literal_id &id,
-                   const RoseVertex v, vector<u8> &msk, vector<u8> &cmp) {
-    const RoseGraph &g = tbi.g;
-
-    // For right now, wuss out and only handle cases with one pred.
-    if (in_degree(v, g) != 1) {
-        return false;
-    }
-
-    // Root successors have no literal before them.
-    if (tbi.isRootSuccessor(v)) {
-        return false;
-    }
-
-    // If we have a single predecessor with a short bound, we may be able to
-    // fill out a mask with the trailing bytes of the previous literal. This
-    // allows us to improve literals like the 'bar' in 'fo.bar'.
-
-    RoseEdge e = *(in_edges(v, g).first);
-    u32 bound = g[e].maxBound;
-    if (bound != g[e].minBound || bound >= HWLM_MASKLEN) {
-        return false;
-    }
-
-    bound += id.s.length();
-    if (bound >= HWLM_MASKLEN) {
-        return false;
-    }
-
-    DEBUG_PRINTF("bound %u\n", bound);
-
-    RoseVertex u = source(e, g);
-    if (g[u].literals.size() != 1) {
-        DEBUG_PRINTF("u has %zu literals\n", g[u].literals.size());
-        return false;
-    }
-
-    u32 u_lit_id = *(g[u].literals.begin());
-    const rose_literal_id &u_id = tbi.literals.right.at(u_lit_id);
-    DEBUG_PRINTF("u has lit: %s\n", escapeString(u_id.s).c_str());
-
-    // Number of characters to take from the back of u's literal.
-    size_t u_len = u_id.s.length();
-    size_t u_sublen = min(u_len, (size_t)HWLM_MASKLEN - bound);
-
-    size_t i = HWLM_MASKLEN - (bound + u_sublen);
-
-    ue2_literal::const_iterator it, ite;
-    for (it = u_id.s.begin() + (u_len - u_sublen), ite = u_id.s.end();
-            it != ite; ++it) {
-        make_and_cmp_mask(*it, &msk.at(i), &cmp.at(i));
-        ++i;
-    }
-
-    return true;
-}
-
-static
-bool findHamsterMask(const RoseBuildImpl &tbi, const rose_literal_id &id,
-                     const rose_literal_info &info, const RoseVertex v,
-                     vector<u8> &msk, vector<u8> &cmp) {
-    // Start with zero masks.
-    msk.assign(HWLM_MASKLEN, 0);
-    cmp.assign(HWLM_MASKLEN, 0);
-
-    // Masks can come from literal benefits (for mixed-case literals).
-    if (info.requires_benefits) {
-        assert(mixed_sensitivity(id.s));
-
-        size_t j = 0;
-        for (ue2_literal::const_reverse_iterator it = id.s.rbegin(),
-                                                 ite = id.s.rend();
-             it != ite && j < HWLM_MASKLEN; ++it, ++j) {
-            size_t offset = HWLM_MASKLEN - j - 1;
-            const CharReach &cr = *it;
-            make_and_cmp_mask(cr, &msk[offset], &cmp[offset]);
-        }
-        return true;
-    }
-
-    const LeftEngInfo &left = tbi.g[v].left;
-    if (left && left.lag < HWLM_MASKLEN) {
-        if (maskFromLeft(left, msk, cmp)) {
-            DEBUG_PRINTF("mask from a leftfix!\n");
-            return true;
-        }
-    }
-
-    if (id.s.length() < HWLM_MASKLEN) {
-        if (maskFromPreds(tbi, id, v, msk, cmp)) {
-            DEBUG_PRINTF("mask from preds!\n");
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static
-bool hamsterMaskCombine(vector<u8> &msk, vector<u8> &cmp,
-                        const vector<u8> &v_msk, const vector<u8> &v_cmp) {
-    assert(msk.size() == HWLM_MASKLEN && cmp.size() == HWLM_MASKLEN);
-    assert(v_msk.size() == HWLM_MASKLEN && v_cmp.size() == HWLM_MASKLEN);
-
-    u8 all_masks = 0;
-
-    for (size_t i = 0; i < HWLM_MASKLEN; i++) {
-        u8 filter = ~(cmp[i] ^ v_cmp[i]);
-        msk[i] &= v_msk[i];
-        msk[i] &= filter;
-        cmp[i] &= filter;
-
-        all_masks |= msk[i];
-    }
-
-    // Return false if we have no bits on in any mask elements.
-    return all_masks != 0;
-}
-
-static
-bool findHamsterMask(const RoseBuildImpl &tbi, const rose_literal_id &id,
-                     const rose_literal_info &info,
-                     vector<u8> &msk, vector<u8> &cmp) {
-    if (!tbi.cc.grey.roseHamsterMasks) {
-        return false;
-    }
-
-    if (!info.delayed_ids.empty()) {
-        // Not safe to add masks to delayed literals at this late stage.
-        return false;
-    }
-
-    size_t num = 0;
-    vector<u8> v_msk, v_cmp;
-
-    for (RoseVertex v : info.vertices) {
-        if (!findHamsterMask(tbi, id, info, v, v_msk, v_cmp)) {
-            DEBUG_PRINTF("no mask\n");
-            return false;
-        }
-
-        if (!num++) {
-            // First (or only) vertex, this becomes the mask/cmp pair.
-            msk = v_msk;
-            cmp = v_cmp;
-        } else {
-            // Multiple vertices with potentially different masks. We combine
-            // them into an 'advisory' mask.
-            if (!hamsterMaskCombine(msk, cmp, v_msk, v_cmp)) {
-                DEBUG_PRINTF("mask went to zero\n");
-                return false;
-            }
-        }
-    }
-
-    normaliseLiteralMask(id.s, msk, cmp);
-
-    if (msk.empty()) {
-        DEBUG_PRINTF("no mask\n");
-        return false;
-    }
-
-    DEBUG_PRINTF("msk=%s, cmp=%s\n", dumpMask(msk).c_str(),
-                 dumpMask(cmp).c_str());
-    return true;
-}
-
-static
-bool isDirectHighlander(const RoseBuildImpl &tbi,
-                        const rose_literal_info &info) {
-    u32 final_id = info.final_id;
-    assert(final_id != MO_INVALID_IDX);
-
-    if ((final_id & LITERAL_MDR_FLAG) == LITERAL_MDR_FLAG) {
-        u32 i = final_id & ~LITERAL_MDR_FLAG;
-        assert(i < tbi.mdr_reports.size());
-        for (ReportID report = tbi.mdr_reports[i]; report != MO_INVALID_IDX;
-             report = tbi.mdr_reports[++i]) {
-            const Report &ir = tbi.rm.getReport(report);
-            if (!isSimpleExhaustible(ir)) {
-                return false;
-            }
-        }
-        return true;
-    } else if (final_id & LITERAL_DR_FLAG) {
-        ReportID report = final_id & ~LITERAL_DR_FLAG;
-        const Report &ir = tbi.rm.getReport(report);
-        if (isSimpleExhaustible(ir)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-// Called by isNoRunsLiteral below.
-static
-bool isNoRunsVertex(const RoseBuildImpl &tbi, NFAVertex u) {
-    const RoseGraph &g = tbi.g;
-    if (!g[u].isBoring()) {
-        DEBUG_PRINTF("u=%zu is not boring\n", g[u].idx);
-        return false;
-    }
-
-    if (!g[u].reports.empty()) {
-        DEBUG_PRINTF("u=%zu has accept\n", g[u].idx);
-        return false;
-    }
-
-    if (g[u].escapes.any()) {
-        DEBUG_PRINTF("u=%zu has escapes\n", g[u].idx);
-        return false;
-    }
-
-    /* TODO: handle non-root roles as well. It can't be that difficult... */
-
-    if (!in_degree_equal_to(u, g, 1)) {
-        DEBUG_PRINTF("u=%zu is not a root role\n", g[u].idx);
-        return false;
-    }
-
-    RoseEdge e;
-    bool exists;
-    tie(e, exists) = edge_by_target(tbi.root, u, g);
-
-    if (!exists) {
-        DEBUG_PRINTF("u=%zu is not a root role\n", g[u].idx);
-        return false;
-    }
-
-    if (g[e].minBound != 0 || g[e].maxBound != ROSE_BOUND_INF) {
-        DEBUG_PRINTF("u=%zu has bounds from root\n", g[u].idx);
-        return false;
-    }
-
-    for (const auto &oe : out_edges_range(u, g)) {
-        RoseVertex v = target(oe, g);
-        if (g[oe].maxBound != ROSE_BOUND_INF) {
-            DEBUG_PRINTF("edge (%zu,%zu) has max bound\n", g[u].idx,
-                    g[target(oe, g)].idx);
-            return false;
-        }
-        if (g[v].left) {
-            DEBUG_PRINTF("v=%zu has rose prefix\n", g[v].idx);
-            return false;
-        }
-    }
-    return true;
-}
-
-static
-bool isNoRunsLiteral(const RoseBuildImpl &tbi, UNUSED const u32 id,
-                     const rose_literal_info &info) {
-    DEBUG_PRINTF("lit id %u\n", id);
-
-    if (info.requires_benefits) {
-        DEBUG_PRINTF("requires benefits\n"); // which would need confirm
-        return false;
-    }
-
-    if (isDirectHighlander(tbi, info)) {
-        DEBUG_PRINTF("highlander direct report\n");
-        return true;
-    }
-
-    // Undelayed vertices.
-    for (RoseVertex v : info.vertices) {
-        if (!isNoRunsVertex(tbi, v)) {
-            return false;
-        }
-    }
-
-    // Delayed vertices.
-    for (u32 d : info.delayed_ids) {
-        assert(d < tbi.literal_info.size());
-        const rose_literal_info &delayed_info = tbi.literal_info.at(d);
-        assert(delayed_info.undelayed_id == id);
-        for (RoseVertex v : delayed_info.vertices) {
-            if (!isNoRunsVertex(tbi, v)) {
-                return false;
-            }
-        }
-    }
-
-    DEBUG_PRINTF("is no-runs literal\n");
-    return true;
-}
-
-void fillHamsterLiteralList(const RoseBuildImpl &tbi, rose_literal_table table,
-                            vector<hwlmLiteral> *hl) {
-    for (const auto &e : tbi.literals.right) {
-        const u32 id = e.first;
-        if (!tbi.hasFinalId(id)) {
-            continue;
-        }
-
-        if (e.second.delay) {
-            continue; /* delay id's are virtual-ish */
-        }
-
-        if (e.second.table != table) {
-            continue; /* wrong table */
-        }
-
-        assert(id < tbi.literal_info.size());
-        const rose_literal_info &info = tbi.literal_info[id];
-        u32 final_id = info.final_id;
-        rose_group groups = info.group_mask;
-        /* Note: requires_benefits are handled in the literal entries */
-        const ue2_literal &lit = e.second.s;
-
-        DEBUG_PRINTF("lit='%s'\n", escapeString(lit).c_str());
-
-        vector<u8> msk = e.second.msk; // copy
-        vector<u8> cmp = e.second.cmp; // copy
-
-        if (msk.empty()) {
-            // Try and pick up an advisory mask.
-            if (!findHamsterMask(tbi, e.second, info, msk, cmp)) {
-                msk.clear(); cmp.clear();
-            } else {
-                DEBUG_PRINTF("picked up late mask %zu\n", msk.size());
-            }
-        }
-
-        bool noruns = isNoRunsLiteral(tbi, id, info);
-
-        if (info.requires_explode) {
-            DEBUG_PRINTF("exploding lit\n");
-            const vector<u8> empty_msk; // msk/cmp will be empty
-            case_iter cit = caseIterateBegin(lit);
-            case_iter cite = caseIterateEnd();
-            for (; cit != cite; ++cit) {
-                DEBUG_PRINTF("id=%u, s='%s', nocase=%d, noruns=%d msk=%s, "
-                             "cmp=%s (exploded)\n",
-                             final_id, escapeString(lit.get_string()).c_str(),
-                             0, noruns, dumpMask(msk).c_str(),
-                             dumpMask(cmp).c_str());
-                hl->push_back(hwlmLiteral(*cit, false, noruns, final_id, groups,
-                                          empty_msk, empty_msk));
-            }
-        } else {
-            const std::string &s = lit.get_string();
-            const bool nocase = lit.any_nocase();
-
-            DEBUG_PRINTF("id=%u, s='%s', nocase=%d, noruns=%d, msk=%s, "
-                         "cmp=%s\n",
-                         final_id, escapeString(s).c_str(), (int)nocase, noruns,
-                         dumpMask(msk).c_str(), dumpMask(cmp).c_str());
-
-            if (!maskIsConsistent(s, nocase, msk, cmp)) {
-                DEBUG_PRINTF("msk/cmp for literal can't match, skipping\n");
-                continue;
-            }
-
-            hl->push_back(hwlmLiteral(lit.get_string(), lit.any_nocase(),
-                                      noruns, final_id, groups, msk, cmp));
-        }
-    }
-}
-
-static
-aligned_unique_ptr<HWLM> buildFloatingMatcher(const RoseBuildImpl &tbi,
-                                              size_t *fsize,
-                                              size_t *historyRequired,
-                                              size_t *streamStateRequired) {
-    *fsize = 0;
-
-    vector<hwlmLiteral> fl;
-    fl.reserve(tbi.literals.size());
-    fillHamsterLiteralList(tbi, ROSE_FLOATING, &fl);
-    if (fl.empty()) {
-        DEBUG_PRINTF("empty floating matcher\n");
-        return nullptr;
-    }
-
-    hwlmStreamingControl ctl;
-    hwlmStreamingControl *ctlp;
-    if (tbi.cc.streaming) {
-        ctl.history_max = tbi.cc.grey.maxHistoryAvailable;
-        ctl.history_min = MAX(*historyRequired,
-                              tbi.cc.grey.minHistoryAvailable);
-        DEBUG_PRINTF("streaming control, history max=%zu, min=%zu\n",
-                     ctl.history_max, ctl.history_min);
-        ctlp = &ctl;
-    } else {
-        ctlp = nullptr; // Null for non-streaming.
-    }
-
-    aligned_unique_ptr<HWLM> ftable =
-        hwlmBuild(fl, ctlp, false, tbi.cc, tbi.getInitialGroups());
-    if (!ftable) {
-        throw CompileError("Unable to generate bytecode.");
-    }
-
-    if (tbi.cc.streaming) {
-        DEBUG_PRINTF("literal_history_required=%zu\n",
-                ctl.literal_history_required);
-        DEBUG_PRINTF("literal_stream_state_required=%zu\n",
-                ctl.literal_stream_state_required);
-        assert(ctl.literal_history_required <= tbi.cc.grey.maxHistoryAvailable);
-        *historyRequired = max(*historyRequired,
-                ctl.literal_history_required);
-        *streamStateRequired = ctl.literal_stream_state_required;
-    }
-
-    *fsize = hwlmSize(ftable.get());
-    assert(*fsize);
-    DEBUG_PRINTF("built floating literal table size %zu bytes\n", *fsize);
-    return ftable;
-}
-
-namespace {
-struct LongerThanLimit {
-    explicit LongerThanLimit(size_t len) : max_len(len) {}
-    bool operator()(const hwlmLiteral &lit) const {
-        return lit.s.length() > max_len;
-    }
-private:
-    size_t max_len;
-};
-}
-
-static
-aligned_unique_ptr<HWLM> buildSmallBlockMatcher(const RoseBuildImpl &tbi,
-                                                size_t *sbsize) {
-    *sbsize = 0;
-
-    if (tbi.cc.streaming) {
-        DEBUG_PRINTF("streaming mode\n");
-        return nullptr;
-    }
-
-    u32 float_min = findMinWidth(tbi, ROSE_FLOATING);
-    if (float_min > ROSE_SMALL_BLOCK_LEN) {
-        DEBUG_PRINTF("floating table has large min width %u, fail\n", float_min);
-        return nullptr;
-    }
-
-    vector<hwlmLiteral> lits;
-    fillHamsterLiteralList(tbi, ROSE_FLOATING, &lits);
-    if (lits.empty()) {
-        DEBUG_PRINTF("no floating table\n");
-        return nullptr;
-    } else if (lits.size() == 1) {
-        DEBUG_PRINTF("single floating literal, noodle will be fast enough\n");
-        return nullptr;
-    }
-
-    vector<hwlmLiteral> anchored_lits;
-    fillHamsterLiteralList(tbi, ROSE_ANCHORED_SMALL_BLOCK, &anchored_lits);
-    if (anchored_lits.empty()) {
-        DEBUG_PRINTF("no small-block anchored literals\n");
-        return nullptr;
-    }
-
-    lits.insert(lits.end(), anchored_lits.begin(), anchored_lits.end());
-
-    // Remove literals that are longer than our small block length, as they can
-    // never match. TODO: improve by removing literals that have a min match
-    // offset greater than ROSE_SMALL_BLOCK_LEN, which will catch anchored cases
-    // with preceding dots that put them over the limit.
-    lits.erase(std::remove_if(lits.begin(), lits.end(),
-                              LongerThanLimit(ROSE_SMALL_BLOCK_LEN)),
-               lits.end());
-
-    if (lits.empty()) {
-        DEBUG_PRINTF("no literals shorter than small block len\n");
-        return nullptr;
-    }
-
-    aligned_unique_ptr<HWLM> hwlm =
-        hwlmBuild(lits, nullptr, true, tbi.cc, tbi.getInitialGroups());
-    if (!hwlm) {
-        throw CompileError("Unable to generate bytecode.");
-    }
-
-    *sbsize = hwlmSize(hwlm.get());
-    assert(*sbsize);
-    DEBUG_PRINTF("built small block literal table size %zu bytes\n", *sbsize);
-    return hwlm;
-}
-
-static
-aligned_unique_ptr<HWLM> buildEodAnchoredMatcher(const RoseBuildImpl &tbi,
-                                                 size_t *esize) {
-    *esize = 0;
-
-    vector<hwlmLiteral> el;
-    fillHamsterLiteralList(tbi, ROSE_EOD_ANCHORED, &el);
-
-    if (el.empty()) {
-        DEBUG_PRINTF("no eod anchored literals\n");
-        assert(!tbi.ematcher_region_size);
-        return nullptr;
-    }
-
-    assert(tbi.ematcher_region_size);
-
-    hwlmStreamingControl *ctlp = nullptr; // not a streaming case
-    aligned_unique_ptr<HWLM> etable =
-        hwlmBuild(el, ctlp, true, tbi.cc, tbi.getInitialGroups());
-    if (!etable) {
-        throw CompileError("Unable to generate bytecode.");
-    }
-
-    *esize = hwlmSize(etable.get());
-    assert(*esize);
-    DEBUG_PRINTF("built eod-anchored literal table size %zu bytes\n", *esize);
-    return etable;
-}
-
-static
-aligned_unique_ptr<sidecar> buildSideMatcher(const RoseBuildImpl &tbi,
-                                             size_t *ssize) {
-    *ssize = 0;
-
-    if (tbi.side_squash_roles.empty()) {
-        DEBUG_PRINTF("no sidecar\n");
-        return nullptr;
-    }
-    assert(tbi.cc.grey.allowSidecar);
-
-    vector<CharReach> sl;
-
-     /* TODO: ensure useful sidecar entries only */
-    for (const CharReach &cr : tbi.side_squash_roles | map_keys) {
-        sl.push_back(cr);
-    }
-
-    aligned_unique_ptr<sidecar> stable = sidecarCompile(sl);
-    if (!stable) {
-        throw CompileError("Unable to generate bytecode.");
-    }
-
-    *ssize = sidecarSize(stable.get());
-    assert(*ssize);
-    DEBUG_PRINTF("built sidecar literal table size %zu bytes\n", *ssize);
-    return stable;
-}
-
 // Adds a sparse iterator to the end of the iterator table, returning its
 // offset.
 static
@@ -2239,9 +1766,8 @@ u32 buildLastByteIter(const RoseGraph &g, build_context &bc) {
 
     for (auto v : vertices_range(g)) {
         if (hasLastByteHistoryOutEdge(g, v)) {
-            u32 role = g[v].role;
-            assert(role < bc.roleTable.size());
-            lb_roles.push_back(bc.roleTable[role].stateIndex);
+            assert(contains(bc.roleStateIndices, v));
+            lb_roles.push_back(bc.roleStateIndices.at(v));
         }
     }
 
@@ -2254,34 +1780,6 @@ u32 buildLastByteIter(const RoseGraph &g, build_context &bc) {
     return addIteratorToTable(bc, iter);
 }
 
-#ifdef DEBUG
-static
-const char *describeHistory(RoseRoleHistory history) {
-    switch (history) {
-    case ROSE_ROLE_HISTORY_NONE:
-        return "NONE";
-    case ROSE_ROLE_HISTORY_ANCH:
-        return "ANCH (previous role at fixed offset)";
-    case ROSE_ROLE_HISTORY_LAST_BYTE:
-        return "LAST_BYTE (previous role matches only at EOD)";
-    case ROSE_ROLE_HISTORY_INVALID:
-        return "INVALID";
-    }
-    assert(0);
-    return "UNKNOWN";
-}
-#endif
-
-static
-u32 calcNfaSize(const vector<aligned_unique_ptr<NFA>> &nfas) {
-    size_t nfas_size = 0;
-
-    for (const auto &n : nfas) {
-        nfas_size += ROUNDUP_CL(n->length);
-    }
-    return verify_u32(nfas_size);
-}
-
 static
 void enforceEngineSizeLimit(const NFA *n, const size_t nfa_size, const Grey &grey) {
     // Global limit.
@@ -2306,87 +1804,20 @@ void enforceEngineSizeLimit(const NFA *n, const size_t nfa_size, const Grey &gre
     }
 }
 
-/* copies nfas into the final engine and updates role to reflect nfa offset */
 static
-u32 copyInNFAs(const RoseBuildImpl &tbi, vector<RoseRole> *roleTable,
-               const vector<aligned_unique_ptr<NFA>> &built_nfas,
-               const set<u32> &no_retrigger_queues, NfaInfo *infos,
-               u32 base_nfa_offset,
-               const map<suffix_id, u32> &suffixes, char *ptr) {
-    const RoseGraph &g = tbi.g;
-    const CompileContext &cc = tbi.cc;
-
-    // Enforce engine count resource limit.
-    if (built_nfas.size() > cc.grey.limitRoseEngineCount) {
-        throw ResourceLimitError();
+u32 findMinFloatingLiteralMatch(const RoseBuildImpl &build,
+                                const vector<raw_dfa> &anchored_dfas) {
+    if (anchored_dfas.size() > 1) {
+        DEBUG_PRINTF("multiple anchored dfas\n");
+        /* We must regard matches from other anchored tables as unordered, as
+         * we do for floating matches. */
+        return 1;
     }
 
-    vector<u32> suffix_base(built_nfas.size());
-    vector<bool> classic_top(built_nfas.size(), false);
-
-    for (u32 i = 0; i < built_nfas.size(); i++) {
-        const NFA *n = built_nfas[i].get();
-
-        // Enforce individual engine size limit.
-        enforceEngineSizeLimit(n, n->length, cc.grey);
-
-        DEBUG_PRINTF("copying in nfa %u: len=%u, offset=%u\n", i, n->length,
-                     base_nfa_offset);
-
-        memcpy(ptr + base_nfa_offset, n, n->length);
-        suffix_base[i] = base_nfa_offset;
-
-        if (!isMultiTopType(n->type)) {
-            classic_top[i] = true;
-        }
-
-        infos[i].nfaOffset = base_nfa_offset;
-        if (contains(no_retrigger_queues, i)) {
-            infos[i].no_retrigger = 1;
-        }
-        base_nfa_offset += ROUNDUP_CL(n->length);
-    }
-
-    /* Write NFA indices into RoseRole structures for suffix NFAs */
-    for (auto v : vertices_range(g)) {
-        if (!g[v].suffix) {
-            continue;
-        }
-
-        u32 nfa_index = suffixes.at(g[v].suffix);
-        assert(nfa_index < suffix_base.size());
-
-        assert(g[v].role < roleTable->size());
-        RoseRole &tr = (*roleTable)[g[v].role];
-        tr.suffixOffset = suffix_base[nfa_index];
-
-        // DFAs/Puffs have no MQE_TOP_N support, so they get a classic TOP
-        // event.
-        if (classic_top[nfa_index]) {
-            assert(!g[v].suffix.graph || onlyOneTop(*g[v].suffix.graph));
-            tr.suffixEvent = MQE_TOP;
-        } else {
-            assert(!g[v].suffix.haig);
-            u32 top = (u32)MQE_TOP_FIRST + g[v].suffix.top;
-            assert(top < MQE_INVALID);
-            tr.suffixEvent = top;
-        }
-
-        /* mark suffixes triggered by etable literals */
-        if (tbi.isInETable(v)) {
-            infos[nfa_index].eod = 1;
-        }
-    }
-
-    return base_nfa_offset;
-}
-
-static
-u32 findMinFloatingLiteralMatch(const RoseBuildImpl &tbi) {
-    const RoseGraph &g = tbi.g;
+    const RoseGraph &g = build.g;
     u32 minWidth = ROSE_BOUND_INF;
     for (auto v : vertices_range(g)) {
-        if (tbi.isAnchored(v) || tbi.isVirtualVertex(v)) {
+        if (build.isAnchored(v) || build.isVirtualVertex(v)) {
             DEBUG_PRINTF("skipping %zu anchored or root\n", g[v].idx);
             continue;
         }
@@ -2402,92 +1833,15 @@ u32 findMinFloatingLiteralMatch(const RoseBuildImpl &tbi) {
     return minWidth;
 }
 
-static
-vector<RoseTrigger> buildRoseTriggerList(const RoseGraph &g, RoseVertex u,
-                         const map<RoseVertex, left_build_info> &leftfix_info) {
-    // Terminator struct that marks the end of each role's trigger list.
-    RoseTrigger terminator;
-    memset(&terminator, 0, sizeof(RoseTrigger));
-    terminator.queue = MO_INVALID_IDX;
-    terminator.event = MQE_INVALID;
-    terminator.cancel_prev_top = false;
-
-    vector<RoseTrigger> rv;
-
-    for (const auto &e : out_edges_range(u, g)) {
-        RoseVertex v = target(e, g);
-        if (!g[v].left) {
-            continue;
-        }
-
-        assert(contains(leftfix_info, v));
-        const left_build_info &rbi = leftfix_info.at(v);
-        if (rbi.has_lookaround) {
-            continue;
-        }
-        assert(rbi.nfa);
-
-        // DFAs have no TOP_N support, so they get a classic MQE_TOP event.
-        u32 top;
-        if (!isMultiTopType(rbi.nfa->type)) {
-            assert(num_tops(g[v].left) == 1);
-            top = MQE_TOP;
-        } else {
-            top = MQE_TOP_FIRST + g[e].rose_top;
-            assert(top < MQE_INVALID);
-        }
-
-        rv.push_back(terminator);
-        RoseTrigger &trigger = rv.back();
-        trigger.queue = rbi.nfa->queueIndex;
-        trigger.event = top;
-        trigger.cancel_prev_top = g[e].rose_cancel_prev_top;
-    }
-
-    if (rv.empty()) {
-        return rv;
-    }
-
-    sort(rv.begin(), rv.end(), RoseTriggerOrdering());
-    rv.erase(unique(rv.begin(), rv.end(), RoseTriggerEquality()), rv.end());
-
-    rv.push_back(terminator);
-
-    return rv;
-}
-
-static
-void buildRoseTriggerLists(const RoseBuildImpl &tbi, build_context &bc) {
-    const RoseGraph &g = tbi.g;
-    for (auto u : vertices_range(g)) {
-        if (tbi.isAnyStart(u) || g[u].literals.empty()
-            || tbi.hasDirectFinalId(u)) {
-            continue;
-        }
-
-        assert(g[u].role < bc.roleTable.size());
-        RoseRole &tr = bc.roleTable.at(g[u].role);
-
-        vector<RoseTrigger> trigs = buildRoseTriggerList(g, u, bc.leftfix_info);
-
-        if (!trigs.empty()) {
-            assert(trigs.size() != 1); /* at min should be trig + term */
-            tr.infixTriggerOffset = add_to_engine_blob(bc, trigs.begin(),
-                                                       trigs.end());
-        }
-    }
-}
-
 static
 void buildSuffixEkeyLists(const RoseBuildImpl &tbi, build_context &bc,
                           const QueueIndexFactory &qif,
-                          const map<suffix_id, u32> &suffixes,
                           vector<u32> *out) {
     out->resize(qif.allocated_count());
 
     map<u32, vector<u32> > qi_to_ekeys; /* for determinism */
 
-    for (const auto &e : suffixes) {
+    for (const auto &e : bc.suffixes) {
         const suffix_id &s = e.first;
         u32 qi = e.second;
         set<u32> ekeys = reportsToEkeys(all_reports(s), tbi.rm);
@@ -2499,8 +1853,7 @@ void buildSuffixEkeyLists(const RoseBuildImpl &tbi, build_context &bc,
 
     /* for each outfix also build elists */
     for (const auto &outfix : tbi.outfixes) {
-        assert(outfix.nfa);
-        u32 qi = outfix.nfa->queueIndex;
+        u32 qi = outfix.get_queue();
         set<u32> ekeys = reportsToEkeys(all_reports(outfix), tbi.rm);
 
         if (!ekeys.empty()) {
@@ -2516,6 +1869,29 @@ void buildSuffixEkeyLists(const RoseBuildImpl &tbi, build_context &bc,
     }
 }
 
+/** Returns sparse iter offset in engine blob. */
+static
+u32 buildEodNfaIterator(build_context &bc, const u32 activeQueueCount) {
+    vector<u32> keys;
+    for (u32 qi = 0; qi < activeQueueCount; ++qi) {
+        const NFA *n = get_nfa_from_blob(bc, qi);
+        if (nfaAcceptsEod(n)) {
+            DEBUG_PRINTF("nfa qi=%u accepts eod\n", qi);
+            keys.push_back(qi);
+        }
+    }
+
+    if (keys.empty()) {
+        return 0;
+    }
+
+    DEBUG_PRINTF("building iter for %zu nfas\n", keys.size());
+
+    vector<mmbit_sparse_iter> iter;
+    mmbBuildSparseIterator(iter, keys, activeQueueCount);
+    return addIteratorToTable(bc, iter);
+}
+
 static
 bool hasMpvTrigger(const set<u32> &reports, const ReportManager &rm) {
     for (u32 r : reports) {
@@ -2549,7 +1925,6 @@ bool anyEndfixMpvTriggers(const RoseBuildImpl &tbi) {
 
     /* outfixes */
     for (const auto &out : tbi.outfixes) {
-        assert(out.nfa);
         if (hasMpvTrigger(all_reports(out), tbi.rm)) {
             return true;
         }
@@ -2569,31 +1944,52 @@ bool hasInternalReport(const set<ReportID> &reports, const ReportManager &rm) {
 }
 
 static
-void populateNfaInfoBasics(NfaInfo *infos, const vector<OutfixInfo> &outfixes,
-                           const ReportManager &rm,
-                           const map<suffix_id, u32> &suffixes,
-                           const vector<u32> &ekeyListOffsets) {
-    for (const auto &out : outfixes) {
-        assert(out.nfa);
-        const u32 qi = out.nfa->queueIndex;
+void populateNfaInfoBasics(const RoseBuildImpl &build, const build_context &bc,
+                           const vector<OutfixInfo> &outfixes,
+                           const vector<u32> &ekeyListOffsets,
+                           const set<u32> &no_retrigger_queues,
+                           NfaInfo *infos) {
+    const u32 num_queues = build.qif.allocated_count();
+    for (u32 qi = 0; qi < num_queues; qi++) {
+        const NFA *n = get_nfa_from_blob(bc, qi);
+        enforceEngineSizeLimit(n, n->length, build.cc.grey);
 
-        infos[qi].in_sbmatcher = out.in_sbmatcher;
-        if (!hasInternalReport(all_reports(out), rm)) {
-            infos[qi].only_external = 1;
-        }
-
-        infos[qi].ekeyListOffset = ekeyListOffsets[qi];
+        NfaInfo &info = infos[qi];
+        info.nfaOffset = bc.engineOffsets.at(qi);
+        info.ekeyListOffset = ekeyListOffsets[qi];
+        info.no_retrigger = contains(no_retrigger_queues, qi) ? 1 : 0;
     }
 
-    for (const auto &e : suffixes) {
+    // Mark outfixes that only trigger external reports.
+    for (const auto &out : outfixes) {
+        const u32 qi = out.get_queue();
+
+        infos[qi].in_sbmatcher = out.in_sbmatcher;
+        if (!hasInternalReport(all_reports(out), build.rm)) {
+            infos[qi].only_external = 1;
+        }
+    }
+
+    // Mark suffixes that only trigger external reports.
+    for (const auto &e : bc.suffixes) {
         const suffix_id &s = e.first;
         u32 qi = e.second;
 
-        if (!hasInternalReport(all_reports(s), rm)) {
+        if (!hasInternalReport(all_reports(s), build.rm)) {
             infos[qi].only_external = 1;
         }
+    }
 
-        infos[qi].ekeyListOffset = ekeyListOffsets[qi];
+    // Mark suffixes triggered by EOD table literals.
+    const RoseGraph &g = build.g;
+    for (auto v : vertices_range(g)) {
+        if (!g[v].suffix) {
+            continue;
+        }
+        u32 qi = bc.suffixes.at(g[v].suffix);
+        if (build.isInETable(v)) {
+            infos[qi].eod = 1;
+        }
     }
 }
 
@@ -2606,96 +2002,6 @@ struct DerivedBoundaryReports {
     set<ReportID> report_at_0_eod_full;
 };
 
-static
-void reserveBoundaryReports(const BoundaryReports &boundary,
-                            const DerivedBoundaryReports &dboundary,
-                            RoseBoundaryReports *out, u32 *currOffset) {
-    u32 curr = *currOffset;
-    curr = ROUNDUP_N(curr, alignof(ReportID));
-    memset(out, 0, sizeof(*out));
-
-    /* report lists are + 1 in size due to terminator */
-    if (!boundary.report_at_eod.empty()) {
-        out->reportEodOffset = curr;
-        curr += sizeof(ReportID) * (boundary.report_at_eod.size() + 1);
-    }
-    if (!boundary.report_at_0.empty()) {
-        out->reportZeroOffset = curr;
-        curr += sizeof(ReportID) * (boundary.report_at_0.size() + 1);
-    }
-    if (!dboundary.report_at_0_eod_full.empty()) {
-        out->reportZeroEodOffset = curr;
-        curr += sizeof(ReportID) * (dboundary.report_at_0_eod_full.size() + 1);
-    }
-
-    DEBUG_PRINTF("report ^:  %zu\n", boundary.report_at_0.size());
-    DEBUG_PRINTF("report $:  %zu\n", boundary.report_at_eod.size());
-    DEBUG_PRINTF("report ^$: %zu\n", dboundary.report_at_0_eod_full.size());
-
-    *currOffset = curr;
-}
-
-static
-void fillInBoundaryReports(RoseEngine *engine, u32 offset,
-                           const set<ReportID> &rl) {
-    if (rl.empty()) {
-        return;
-    }
-
-    u32 *out = (u32 *)((char *)engine + offset);
-    assert(ISALIGNED(out));
-
-    for (ReportID r : rl) {
-        *out = r;
-        ++out;
-    }
-
-    *out = MO_INVALID_IDX;
-}
-
-static
-void populateBoundaryReports(RoseEngine *engine,
-                             const BoundaryReports &boundary,
-                             const DerivedBoundaryReports &dboundary,
-                             const RoseBoundaryReports &offsets) {
-    engine->boundary.reportEodOffset = offsets.reportEodOffset;
-    engine->boundary.reportZeroOffset = offsets.reportZeroOffset;
-    engine->boundary.reportZeroEodOffset = offsets.reportZeroEodOffset;
-
-    fillInBoundaryReports(engine, offsets.reportEodOffset,
-                          boundary.report_at_eod);
-    fillInBoundaryReports(engine, offsets.reportZeroOffset,
-                          boundary.report_at_0);
-    fillInBoundaryReports(engine, offsets.reportZeroEodOffset,
-                          dboundary.report_at_0_eod_full);
-}
-
-static
-void fillInReportInfo(RoseEngine *engine, u32 reportOffset,
-                      const ReportManager &rm, const vector<Report> &reports) {
-    internal_report *dest = (internal_report *)((char *)engine + reportOffset);
-    engine->intReportOffset = reportOffset;
-    engine->intReportCount = (u32)reports.size();
-
-    assert(ISALIGNED(dest));
-
-    for (const auto &report : reports) {
-        writeInternalReport(report, rm, dest++);
-    }
-
-    DEBUG_PRINTF("%zu reports of size %zu\n", reports.size(),
-                 sizeof(internal_report));
-}
-
-static
-bool hasSimpleReports(const vector<Report> &reports) {
-    auto it = find_if(reports.begin(), reports.end(), isComplexReport);
-
-    DEBUG_PRINTF("runtime has %scomplex reports\n",
-                 it == reports.end() ? "no " : "");
-    return it == reports.end();
-}
-
 static
 void prepSomRevNfas(const SomSlotManager &ssm, u32 *rev_nfa_table_offset,
                     vector<u32> *nfa_offsets, u32 *currOffset) {
@@ -2770,52 +2076,234 @@ getLiteralInfoByFinalId(const RoseBuildImpl &build, u32 final_id) {
     return out;
 }
 
+/**
+ * \brief Flattens a list of role programs into one finalised program with its
+ * fail_jump/done_jump targets set correctly.
+ */
 static
-void buildRootRoleTable(const RoseBuildImpl &tbi, u32 roleTableOffset,
-                        vector<RoseLiteral> &literalTable,
-                        vector<u32> *rootRoleTable) {
-    for (u32 id = 0; id < literalTable.size(); id++) {
-        RoseLiteral &tl = literalTable[id];
-        const rose_literal_info &lit_info =
-            **getLiteralInfoByFinalId(tbi, id).begin();
-        const auto &vertices = lit_info.vertices;
+vector<RoseInstruction>
+flattenProgram(const vector<vector<RoseInstruction>> &programs) {
+    vector<RoseInstruction> out;
 
-        tl.rootRoleOffset = verify_u32(rootRoleTable->size());
-        tl.rootRoleCount = 0;
+    vector<u32> offsets; // offset of each instruction (bytes)
+    vector<u32> blocks; // track which block we're in
+    vector<u32> block_offsets; // start offsets for each block
 
-        for (RoseVertex v : vertices) {
-            if (tbi.isRootSuccessor(v)) {
-                if (tbi.hasDirectFinalId(v)) {
-                    DEBUG_PRINTF("[skip root role %u as direct]\n",
-                                 tbi.g[v].role);
-                    continue;
-                }
-                assert(tbi.isRootSuccessor(v));
-                u32 role_offset
-                    = roleTableOffset + tbi.g[v].role * sizeof(RoseRole);
-                rootRoleTable->push_back(role_offset);
-                tl.rootRoleCount++;
-                DEBUG_PRINTF("root role %u\n", tbi.g[v].role);
-            }
+    DEBUG_PRINTF("%zu program blocks\n", programs.size());
+
+    size_t curr_offset = 0;
+    for (const auto &program : programs) {
+        DEBUG_PRINTF("block with %zu instructions\n", program.size());
+        block_offsets.push_back(curr_offset);
+        for (const auto &ri : program) {
+            assert(ri.code() != ROSE_INSTR_END);
+            out.push_back(ri);
+            offsets.push_back(curr_offset);
+            blocks.push_back(block_offsets.size() - 1);
+            curr_offset += ROUNDUP_N(ri.length(), ROSE_INSTR_MIN_ALIGN);
         }
-
-        if (!tl.rootRoleCount) {
-            tl.rootRoleOffset = 0;
-        } else if (tl.rootRoleCount > 1) {
-            // Sort the entries for this literal by role index
-            vector<u32>::iterator begin = rootRoleTable->begin()
-                                        + tl.rootRoleOffset;
-            vector<u32>::iterator end = begin + tl.rootRoleCount;
-            sort(begin, end);
-        } else if (tl.rootRoleCount == 1) {
-            /* if there is only one root role, the rose literal stores the
-             * offset directly */
-            tl.rootRoleOffset = (*rootRoleTable)[tl.rootRoleOffset];
-        }
-
-        DEBUG_PRINTF("literal %u: %u root roles, starting from idx=%u\n", id,
-                     tl.rootRoleCount, tl.rootRoleOffset);
     }
+
+    // Add a final END instruction, which is its own block.
+    out.emplace_back(ROSE_INSTR_END);
+    block_offsets.push_back(curr_offset);
+    offsets.push_back(curr_offset);
+
+    assert(offsets.size() == out.size());
+
+    for (size_t i = 0; i < out.size(); i++) {
+        auto &ri = out[i];
+
+        u32 jump_target = 0;
+        switch (ri.target) {
+        case JumpTarget::NO_JUMP:
+        case JumpTarget::FIXUP_DONE:
+            continue; // Next instruction.
+        case JumpTarget::PROGRAM_END:
+            assert(i != out.size() - 1);
+            jump_target = offsets.back();
+            break;
+        case JumpTarget::NEXT_BLOCK:
+            assert(blocks[i] + 1 < block_offsets.size());
+            jump_target = block_offsets[blocks[i] + 1];
+            break;
+        }
+
+        // We currently always make progress and never jump backwards.
+        assert(jump_target > offsets[i]);
+        assert(jump_target <= offsets.back());
+        u32 jump_val = jump_target - offsets[i];
+
+        switch (ri.code()) {
+        case ROSE_INSTR_ANCHORED_DELAY:
+            ri.u.anchoredDelay.done_jump = jump_val;
+            break;
+        case ROSE_INSTR_CHECK_ONLY_EOD:
+            ri.u.checkOnlyEod.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_CHECK_BOUNDS:
+            ri.u.checkBounds.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_CHECK_NOT_HANDLED:
+            ri.u.checkNotHandled.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_CHECK_LOOKAROUND:
+            ri.u.checkLookaround.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_CHECK_INFIX:
+            ri.u.checkInfix.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_CHECK_PREFIX:
+            ri.u.checkPrefix.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_DEDUPE:
+            ri.u.dedupe.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_DEDUPE_SOM:
+            ri.u.dedupeSom.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_DEDUPE_AND_REPORT:
+            ri.u.dedupeAndReport.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_CHECK_EXHAUSTED:
+            ri.u.checkExhausted.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_CHECK_MIN_LENGTH:
+            ri.u.checkMinLength.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_CHECK_STATE:
+            ri.u.checkState.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_SPARSE_ITER_BEGIN:
+            ri.u.sparseIterBegin.fail_jump = jump_val;
+            break;
+        case ROSE_INSTR_SPARSE_ITER_NEXT:
+            ri.u.sparseIterNext.fail_jump = jump_val;
+            break;
+        default:
+            assert(0); // Unhandled opcode?
+            break;
+        }
+
+        ri.target = JumpTarget::FIXUP_DONE;
+    }
+
+    return out;
+}
+
+static
+void applyFinalSpecialisation(vector<RoseInstruction> &program) {
+    assert(!program.empty());
+    assert(program.back().code() == ROSE_INSTR_END);
+    if (program.size() < 2) {
+        return;
+    }
+
+    /* Replace the second-to-last instruction (before END) with a one-shot
+     * specialisation if available. */
+    auto &ri = *(next(program.rbegin()));
+    switch (ri.code()) {
+    case ROSE_INSTR_REPORT: {
+        DEBUG_PRINTF("replacing REPORT with FINAL_REPORT\n");
+        auto ri2 = RoseInstruction(ROSE_INSTR_FINAL_REPORT);
+        ri2.u.finalReport.onmatch = ri.u.report.onmatch;
+        ri2.u.finalReport.offset_adjust = ri.u.report.offset_adjust;
+        ri = ri2;
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+static
+void recordResources(RoseResources &resources,
+                     const vector<RoseInstruction> &program) {
+    for (const auto &ri : program) {
+        switch (ri.code()) {
+        case ROSE_INSTR_TRIGGER_SUFFIX:
+            resources.has_suffixes = true;
+            break;
+        case ROSE_INSTR_TRIGGER_INFIX:
+        case ROSE_INSTR_CHECK_INFIX:
+        case ROSE_INSTR_CHECK_PREFIX:
+        case ROSE_INSTR_SOM_LEFTFIX:
+            resources.has_leftfixes = true;
+            break;
+        case ROSE_INSTR_SET_STATE:
+        case ROSE_INSTR_CHECK_STATE:
+        case ROSE_INSTR_SPARSE_ITER_BEGIN:
+        case ROSE_INSTR_SPARSE_ITER_NEXT:
+            resources.has_states = true;
+            break;
+        case ROSE_INSTR_CHECK_GROUPS:
+            resources.checks_groups = true;
+            break;
+        case ROSE_INSTR_PUSH_DELAYED:
+            resources.has_lit_delay = true;
+            break;
+        case ROSE_INSTR_CHECK_LIT_MASK:
+            resources.has_lit_mask = true;
+            break;
+        default:
+            break;
+        }
+    }
+}
+
+static
+void recordResources(RoseResources &resources,
+                     const RoseBuildImpl &build) {
+    if (!build.outfixes.empty()) {
+        resources.has_outfixes = true;
+    }
+    for (u32 i = 0; i < build.literal_info.size(); i++) {
+        if (build.hasFinalId(i)) {
+            resources.has_literals = true;
+            break;
+        }
+    }
+}
+
+static
+u32 writeProgram(build_context &bc, const vector<RoseInstruction> &program) {
+    if (program.empty()) {
+        DEBUG_PRINTF("no program\n");
+        return 0;
+    }
+
+    assert(program.back().code() == ROSE_INSTR_END);
+    assert(program.size() >= 1);
+
+    // This program must have been flattened; i.e. all check instructions must
+    // have their jump offsets set.
+    assert(all_of(begin(program), end(program), [](const RoseInstruction &ri) {
+        return ri.target == JumpTarget::NO_JUMP ||
+               ri.target == JumpTarget::FIXUP_DONE;
+    }));
+
+    auto it = bc.program_cache.find(program);
+    if (it != end(bc.program_cache)) {
+        DEBUG_PRINTF("reusing cached program at %u\n", it->second);
+        return it->second;
+    }
+
+    recordResources(bc.resources, program);
+
+    DEBUG_PRINTF("writing %zu instructions\n", program.size());
+    u32 programOffset = 0;
+    for (const auto &ri : program) {
+        u32 offset =
+            add_to_engine_blob(bc, ri.get(), ri.length(), ROSE_INSTR_MIN_ALIGN);
+        DEBUG_PRINTF("code %u len %zu written at offset %u\n", ri.code(),
+                     ri.length(), offset);
+        if (!programOffset) {
+            programOffset = offset;
+        }
+    }
+    DEBUG_PRINTF("program begins at offset %u\n", programOffset);
+    bc.program_cache.emplace(program, programOffset);
+    return programOffset;
 }
 
 static
@@ -2840,12 +2328,10 @@ void buildActiveLeftIter(const vector<LeftNfaInfo> &leftTable,
 }
 
 static
-bool hasEodAnchors(const RoseBuildImpl &tbi,
-                   const vector<aligned_unique_ptr<NFA>> &built_nfas,
+bool hasEodAnchors(const RoseBuildImpl &tbi, const build_context &bc,
                    u32 outfixEndQueue) {
-    assert(outfixEndQueue <= built_nfas.size());
     for (u32 i = 0; i < outfixEndQueue; i++) {
-        if (nfaAcceptsEod(built_nfas[i].get())) {
+        if (nfaAcceptsEod(get_nfa_from_blob(bc, i))) {
             DEBUG_PRINTF("outfix has eod\n");
             return true;
         }
@@ -2869,293 +2355,6 @@ bool hasEodAnchors(const RoseBuildImpl &tbi,
     return false;
 }
 
-static
-void fetchEodAnchors(map<ReportID, vector<RoseEdge> > &eods,
-                     const RoseGraph &g) {
-    for (auto v : vertices_range(g)) {
-        if (!g[v].eod_accept) {
-            continue;
-        }
-
-        DEBUG_PRINTF("vertex %zu (with %zu preds) fires on EOD\n", g[v].idx,
-                     in_degree(v, g));
-
-        assert(!g[v].reports.empty());
-        for (const auto r : g[v].reports) {
-            // In-edges go into eod list.
-            for (const auto &e : in_edges_range(v, g)) {
-                eods[r].push_back(e);
-            }
-        }
-    }
-}
-
-/* creates (and adds to rose) a sparse iterator visiting pred states/roles,
- * returns a pair:
- * - the offset of the itermap
- * - the offset for the sparse iterator.
- */
-static
-pair<u32, u32> addPredSparseIter(build_context &bc,
-                      const map<u32, vector<RoseIterRole> > &predStates) {
-    vector<u32> keys;
-    for (u32 k : predStates | map_keys) {
-        keys.push_back(k);
-    }
-
-    vector<mmbit_sparse_iter> iter;
-    mmbBuildSparseIterator(iter, keys, bc.numStates);
-    assert(!iter.empty());
-    DEBUG_PRINTF("iter size = %zu\n", iter.size());
-
-    // Build mapping tables and add to iter table
-    u32 iterOffset = addIteratorToTable(bc, iter);
-
-    vector<RoseIterMapping> itermap;
-    for (const auto &p : predStates) {
-        u32 iterRoleOffset = add_to_engine_blob(bc, p.second.begin(),
-                                                p.second.end());
-        itermap.push_back(RoseIterMapping());
-        itermap.back().offset = iterRoleOffset;
-        itermap.back().count = verify_u32(p.second.size());
-    }
-    u32 iterMapOffset = add_to_engine_blob(bc, itermap.begin(), itermap.end());
-
-    return make_pair(iterMapOffset, iterOffset);
-}
-
-static
-void createPred(const RoseBuildImpl &tbi, build_context &bc,
-                const RoseEdge &e, vector<RosePred> &predTable) {
-    const RoseGraph &g = tbi.g;
-
-    DEBUG_PRINTF("building pred %zu of type %s\n", predTable.size(),
-                 describeHistory(g[e].history));
-    RoseVertex u = source(e, g);
-    RoseVertex v = target(e, g);
-
-    u32 lit_length = 0;
-    if (!g[v].eod_accept) {
-        // Use the minimum literal length.
-        lit_length = verify_u32(tbi.minLiteralLen(v));
-    }
-
-    bc.rolePredecessors[g[v].role].push_back(verify_u32(predTable.size()));
-
-    predTable.push_back(RosePred());
-    RosePred &tp = predTable.back();
-    memset(&tp, 0, sizeof(tp));
-    tp.role = g[u].role;
-    tp.minBound = g[e].minBound + lit_length;
-    tp.maxBound = g[e].maxBound == ROSE_BOUND_INF ? ROSE_BOUND_INF
-                                                 : g[e].maxBound + lit_length;
-
-    // Find the history scheme appropriate to this edge. Note that these may be
-    // updated later, as the history collected by the predecessor role is
-    // dependent on all its out edges.
-    tp.historyCheck = g[e].history;
-    if (tp.historyCheck == ROSE_ROLE_HISTORY_ANCH) {
-        assert(g[u].max_offset != ROSE_BOUND_INF);
-        /* pred role does not need to know about history scheme */
-        DEBUG_PRINTF("absing (%u,%u + %u) u%u/%zu v%u/%zu\n", tp.minBound,
-                     tp.maxBound, g[u].max_offset, g[u].role, g[u].idx,
-                     g[v].role, g[v].idx);
-        tp.minBound += g[u].max_offset; /* make absolute */
-        if (tp.maxBound != ROSE_BOUND_INF) {
-            tp.maxBound += g[u].max_offset; /* make absolute */
-        }
-    }
-
-    if (tp.historyCheck == ROSE_ROLE_HISTORY_NONE) {
-        tp.minBound = 0;
-    }
-
-    DEBUG_PRINTF("built pred %zu of %u %u %hhu:%s\n", predTable.size() - 1,
-                 tp.minBound, tp.maxBound, tp.historyCheck,
-                 describeHistory((RoseRoleHistory)tp.historyCheck));
-}
-
-/* returns a pair containing the iter map offset and iter offset */
-static
-pair<u32, u32> buildEodAnchorRoles(RoseBuildImpl &tbi, build_context &bc,
-                                   vector<RosePred> &predTable) {
-    const RoseGraph &g = tbi.g;
-    map<ReportID, vector<RoseEdge> > eods;
-    fetchEodAnchors(eods, g);
-
-    if (eods.empty()) {
-        DEBUG_PRINTF("no EOD anchors\n");
-        return {0, 0};
-    }
-
-    // pred state id -> role/pred entries
-    map<u32, vector<RoseIterRole> > predStates;
-
-    for (const auto &er : eods) {
-        // Create a role to fire this particular report.
-        DEBUG_PRINTF("creating EOD accept role %zu for report %u\n",
-                     bc.roleTable.size(), er.first);
-        bc.roleTable.push_back(RoseRole());
-        RoseRole &tr = bc.roleTable.back();
-        memset(&tr, 0, sizeof(tr));
-        tr.stateIndex = MMB_INVALID;
-        tr.predOffset = ROSE_OFFSET_INVALID;
-        tr.reportId = er.first;
-        tr.flags = ROSE_ROLE_FLAG_ACCEPT_EOD;
-
-        // Collect the state IDs of this report's vertices to add to the EOD
-        // sparse iterator, creating pred entries appropriately.
-        for (const auto &e : er.second) {
-            RoseVertex v = source(e, g);
-            DEBUG_PRINTF("vertex %zu has role %u\n", g[v].idx, g[v].role);
-            assert(g[v].role < bc.roleTable.size());
-            RoseRole &predRole = bc.roleTable[g[v].role];
-
-            createPred(tbi, bc, e, predTable);
-            const RosePred &tp = predTable.back();
-
-            RoseIterRole ir = {
-                (u32)(bc.roleTable.size() - 1),
-                (u32)(predTable.size() - 1)
-            };
-            predStates[predRole.stateIndex].push_back(ir);
-
-            if (out_degree(v, g) == 1 && tp.minBound == 0 && tp.maxBound == 0) {
-                // Since it leads ONLY to an EOD accept with bounds (0, 0), we
-                // can tag this role with the "must match at end of block"
-                // flag.
-                DEBUG_PRINTF("flagging role %u as ONLY_AT_END\n", g[v].role);
-
-                /* There is no pointing enforcing this check at runtime if
-                 * the predRole is only fired by eod event literal */
-                if (g[v].literals.size() != 1
-                    || *g[v].literals.begin() != tbi.eod_event_literal_id) {
-                    predRole.flags |= ROSE_ROLE_FLAG_ONLY_AT_END;
-                }
-            }
-            predRole.flags |= ROSE_ROLE_FLAG_PRED_OF_EOD;
-        }
-    }
-
-    return addPredSparseIter(bc, predStates);
-}
-
-static
-void buildSideEntriesAndIters(const RoseBuildImpl &tbi, build_context &bc,
-                              const set<RoseVertex> &squash_roles,
-                              vector<RoseSide> &sideTable) {
-    const RoseGraph &g = tbi.g;
-
-    sideTable.push_back(RoseSide()); /* index in array gives an implicit id */
-    RoseSide &tsb = sideTable.back();
-    memset(&tsb, 0, sizeof(tsb));
-
-    if (squash_roles.empty()) {
-        return;
-    }
-
-    set<RoseVertex> squashed_succ;
-
-    // Build a vector of the roles' state IDs
-    vector<u32> states;
-    for (RoseVertex v : squash_roles) {
-        assert(g[v].role < bc.roleTable.size());
-        const RoseRole &tr = bc.roleTable[g[v].role];
-        DEBUG_PRINTF("considering role %u, state index %u\n", g[v].role,
-                     tr.stateIndex);
-        assert(tr.stateIndex != MMB_INVALID);
-
-        states.push_back(tr.stateIndex);
-        DEBUG_PRINTF("side %zu squashes state index %u/role %u\n",
-                     sideTable.size() - 1, tr.stateIndex, g[v].role);
-
-        /* we cannot allow groups to be squashed if the source vertex is in an
-         * anchored table due to ordering issue mean that a literals cannot
-         * set groups */
-        if (tbi.isAnchored(v) && g[v].max_offset != 1) {
-            DEBUG_PRINTF("%u has anchored table pred no squashy\n", g[v].role);
-            continue;
-        }
-
-        DEBUG_PRINTF("role %u is fine to g squash\n", g[v].role);
-
-        for (auto w : adjacent_vertices_range(v, g)) {
-            if (in_degree(w, g) == 1) { /* TODO: improve: check that each pred
-                                         * is in id's squash role */
-                squashed_succ.insert(w);
-            }
-        }
-    }
-
-    // Build sparse iterators and add to table.
-    assert(!states.empty());
-
-    vector<mmbit_sparse_iter> iter;
-    mmbBuildSparseIterator(iter, states, bc.numStates);
-    assert(!iter.empty());
-    tsb.squashIterOffset = addIteratorToTable(bc, iter);
-
-    // Build a mask of groups.
-    rose_group squash_groups = 0;
-    for (u32 i = 0; i < ROSE_GROUPS_MAX; i++) {
-        if (!contains(tbi.group_to_literal, i)) {
-            continue;
-        }
-
-        DEBUG_PRINTF("checking group %u for %zu's squash mask\n", i,
-                     sideTable.size() - 1);
-
-        const set<u32> &group_lits = tbi.group_to_literal.find(i)->second;
-
-        /* check for each literal in this group if it is squashed by this
-         * sidecar escape */
-        for (u32 lit : group_lits) {
-            DEBUG_PRINTF("inspecting lit %u\n", lit);
-            const rose_literal_info &this_info = tbi.literal_info.at(lit);
-
-            /* check that all roles belonging to this literal are squashed */
-            for (RoseVertex v : this_info.vertices) {
-                DEBUG_PRINTF("checking if role is squashed %u...\n", g[v].role);
-                if (squashed_succ.find(v) != squashed_succ.end()) {
-                    continue;
-                }
-
-                DEBUG_PRINTF("...role not taken %u\n", g[v].role);
-
-                /* if the literal is length 1 and anchored (0,0) when can ignore
-                 * it as any matching must have happened before the side lit
-                 * arrived */
-                if (g[v].max_offset == 1) {
-                    DEBUG_PRINTF("we can ignore this role as 1st byte only\n");
-                    continue;
-                }
-
-                goto fail_group;
-            }
-        }
-
-        continue;
-
-    fail_group:
-        DEBUG_PRINTF("group %u is not squashed\n", i);
-        /* we need to keep this group active */
-        squash_groups |= 1ULL << i;
-    }
-
-    DEBUG_PRINTF("%zu group squash mask: %016llx\n", sideTable.size() - 1,
-                 squash_groups);
-    tsb.squashGroupMask = squash_groups;
-}
-
-// Construct sparse iterators for squashes
-static
-void buildSideTable(const RoseBuildImpl &build, build_context &bc,
-                    vector<RoseSide> &sideTable) {
-    for (const auto &e : build.side_squash_roles) {
-        buildSideEntriesAndIters(build, bc, e.second, sideTable);
-    }
-}
-
 static
 void fillLookaroundTables(char *look_base, char *reach_base,
                           const vector<LookEntry> &look_vec) {
@@ -3194,375 +2393,759 @@ bool hasBoundaryReports(const BoundaryReports &boundary) {
     return false;
 }
 
+/**
+ * \brief True if the given vertex is a role that can only be switched on at
+ * EOD.
+ */
 static
-bool needsSidecarCatchup(const RoseBuildImpl &build, u32 id) {
-    const RoseGraph &g = build.g;
+bool onlyAtEod(const RoseBuildImpl &tbi, RoseVertex v) {
+    const RoseGraph &g = tbi.g;
 
-    for (RoseVertex v : build.literal_info.at(id).vertices) {
-        if (g[v].escapes.any()) {
-            return true;
+    // All such roles have only (0,0) edges to vertices with the eod_accept
+    // property, and no other effects (suffixes, ordinary reports, etc, etc).
+
+    if (isLeafNode(v, g) || !g[v].reports.empty() || g[v].suffix) {
+        return false;
+    }
+
+    for (const auto &e : out_edges_range(v, g)) {
+        RoseVertex w = target(e, g);
+        if (!g[w].eod_accept) {
+            return false;
         }
+        assert(!g[w].reports.empty());
+        assert(g[w].literals.empty());
 
-        for (RoseVertex u : inv_adjacent_vertices_range(v, g)) {
-            if (g[u].escapes.any()) {
-                return true;
+        if (g[e].minBound || g[e].maxBound) {
+            return false;
+        }
+    }
+
+    /* There is no pointing enforcing this check at runtime if
+     * this role is only fired by the eod event literal */
+    if (tbi.eod_event_literal_id != MO_INVALID_IDX &&
+        g[v].literals.size() == 1 &&
+        *g[v].literals.begin() == tbi.eod_event_literal_id) {
+        return false;
+    }
+
+    return true;
+}
+
+static
+void makeRoleLookaround(RoseBuildImpl &build, build_context &bc, RoseVertex v,
+                        vector<RoseInstruction> &program) {
+    if (!build.cc.grey.roseLookaroundMasks) {
+        return;
+    }
+
+    vector<LookEntry> look;
+
+    // Lookaround from leftfix (mandatory).
+    if (contains(bc.leftfix_info, v) && bc.leftfix_info.at(v).has_lookaround) {
+        DEBUG_PRINTF("using leftfix lookaround\n");
+        look = bc.leftfix_info.at(v).lookaround;
+    }
+
+    // We may be able to find more lookaround info (advisory) and merge it
+    // in.
+    vector<LookEntry> look_more;
+    findLookaroundMasks(build, v, look_more);
+    mergeLookaround(look, look_more);
+
+    if (look.empty()) {
+        return;
+    }
+
+    DEBUG_PRINTF("role has lookaround\n");
+    u32 look_idx;
+    auto it = bc.lookaround_cache.find(look);
+    if (it != bc.lookaround_cache.end()) {
+        DEBUG_PRINTF("reusing look at idx %zu\n", it->second);
+        look_idx = verify_u32(it->second);
+    } else {
+        size_t idx = bc.lookaround.size();
+        bc.lookaround_cache.emplace(look, idx);
+        insert(&bc.lookaround, bc.lookaround.end(), look);
+        DEBUG_PRINTF("adding look at idx %zu\n", idx);
+        look_idx = verify_u32(idx);
+    }
+    u32 look_count = verify_u32(look.size());
+
+    auto ri = RoseInstruction(ROSE_INSTR_CHECK_LOOKAROUND,
+                              JumpTarget::NEXT_BLOCK);
+    ri.u.checkLookaround.index = look_idx;
+    ri.u.checkLookaround.count = look_count;
+    program.push_back(ri);
+}
+
+static
+void makeRoleCheckLeftfix(RoseBuildImpl &build, build_context &bc, RoseVertex v,
+                          vector<RoseInstruction> &program) {
+    auto it = bc.leftfix_info.find(v);
+    if (it == end(bc.leftfix_info)) {
+        return;
+    }
+    const left_build_info &lni = it->second;
+    if (lni.has_lookaround) {
+        return; // Leftfix completely implemented by lookaround.
+    }
+
+    assert(!build.cc.streaming ||
+           build.g[v].left.lag <= MAX_STORED_LEFTFIX_LAG);
+
+    bool is_prefix = build.isRootSuccessor(v);
+    if (is_prefix) {
+        auto ri =
+            RoseInstruction(ROSE_INSTR_CHECK_PREFIX, JumpTarget::NEXT_BLOCK);
+        ri.u.checkPrefix.queue = lni.queue;
+        ri.u.checkPrefix.lag = build.g[v].left.lag;
+        ri.u.checkPrefix.report = build.g[v].left.leftfix_report;
+        program.push_back(move(ri));
+    } else {
+        auto ri =
+            RoseInstruction(ROSE_INSTR_CHECK_INFIX, JumpTarget::NEXT_BLOCK);
+        ri.u.checkInfix.queue = lni.queue;
+        ri.u.checkInfix.lag = build.g[v].left.lag;
+        ri.u.checkInfix.report = build.g[v].left.leftfix_report;
+        program.push_back(move(ri));
+    }
+}
+
+static
+void makeRoleAnchoredDelay(RoseBuildImpl &build, build_context &bc,
+                           RoseVertex v, vector<RoseInstruction> &program) {
+    // Only relevant for roles that can be triggered by the anchored table.
+    if (!build.isAnchored(v)) {
+        return;
+    }
+
+    // If this match cannot occur after floatingMinLiteralMatchOffset, we do
+    // not need this check.
+    if (build.g[v].max_offset <= bc.floatingMinLiteralMatchOffset) {
+        return;
+    }
+
+    auto ri = RoseInstruction(ROSE_INSTR_ANCHORED_DELAY,
+                              JumpTarget::NEXT_BLOCK);
+    ri.u.anchoredDelay.groups = build.g[v].groups;
+    program.push_back(ri);
+}
+
+static
+void makeDedupe(const RoseBuildImpl &build, const Report &report,
+                vector<RoseInstruction> &report_block) {
+    auto ri = RoseInstruction(ROSE_INSTR_DEDUPE, JumpTarget::NEXT_BLOCK);
+    ri.u.dedupe.quash_som = report.quashSom;
+    ri.u.dedupe.dkey = build.rm.getDkey(report);
+    ri.u.dedupe.offset_adjust = report.offsetAdjust;
+    report_block.push_back(move(ri));
+}
+
+static
+void makeDedupeSom(const RoseBuildImpl &build, const Report &report,
+                   vector<RoseInstruction> &report_block) {
+    auto ri = RoseInstruction(ROSE_INSTR_DEDUPE_SOM, JumpTarget::NEXT_BLOCK);
+    ri.u.dedupeSom.quash_som = report.quashSom;
+    ri.u.dedupeSom.dkey = build.rm.getDkey(report);
+    ri.u.dedupeSom.offset_adjust = report.offsetAdjust;
+    report_block.push_back(move(ri));
+}
+
+static
+void makeCatchup(RoseBuildImpl &build, build_context &bc,
+                 const flat_set<ReportID> &reports,
+                 vector<RoseInstruction> &program) {
+    if (!bc.needs_catchup) {
+        return;
+    }
+
+    // Everything except the INTERNAL_ROSE_CHAIN report needs catchup to run
+    // before reports are triggered.
+
+    auto report_needs_catchup = [&](const ReportID &id) {
+        const Report &report = build.rm.getReport(id);
+        return report.type != INTERNAL_ROSE_CHAIN;
+    };
+
+    if (!any_of(begin(reports), end(reports), report_needs_catchup)) {
+        DEBUG_PRINTF("none of the given reports needs catchup\n");
+        return;
+    }
+
+    program.emplace_back(ROSE_INSTR_CATCH_UP);
+}
+
+static
+void makeCatchupMpv(RoseBuildImpl &build, build_context &bc, ReportID id,
+                    vector<RoseInstruction> &program) {
+    if (!bc.needs_mpv_catchup) {
+        return;
+    }
+
+    const Report &report = build.rm.getReport(id);
+    if (report.type == INTERNAL_ROSE_CHAIN) {
+        return;
+    }
+
+    program.emplace_back(ROSE_INSTR_CATCH_UP_MPV);
+}
+
+static
+void writeSomOperation(const Report &report, som_operation *op) {
+    assert(op);
+
+    switch (report.type) {
+    case EXTERNAL_CALLBACK_SOM_REL:
+        op->type = SOM_EXTERNAL_CALLBACK_REL;
+        break;
+    case INTERNAL_SOM_LOC_SET:
+        op->type = SOM_INTERNAL_LOC_SET;
+        break;
+    case INTERNAL_SOM_LOC_SET_IF_UNSET:
+        op->type = SOM_INTERNAL_LOC_SET_IF_UNSET;
+        break;
+    case INTERNAL_SOM_LOC_SET_IF_WRITABLE:
+        op->type = SOM_INTERNAL_LOC_SET_IF_WRITABLE;
+        break;
+    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA:
+        op->type = SOM_INTERNAL_LOC_SET_REV_NFA;
+        break;
+    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET:
+        op->type = SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET;
+        break;
+    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE:
+        op->type = SOM_INTERNAL_LOC_SET_REV_NFA_IF_WRITABLE;
+        break;
+    case INTERNAL_SOM_LOC_COPY:
+        op->type = SOM_INTERNAL_LOC_COPY;
+        break;
+    case INTERNAL_SOM_LOC_COPY_IF_WRITABLE:
+        op->type = SOM_INTERNAL_LOC_COPY_IF_WRITABLE;
+        break;
+    case INTERNAL_SOM_LOC_MAKE_WRITABLE:
+        op->type = SOM_INTERNAL_LOC_MAKE_WRITABLE;
+        break;
+    case EXTERNAL_CALLBACK_SOM_STORED:
+        op->type = SOM_EXTERNAL_CALLBACK_STORED;
+        break;
+    case EXTERNAL_CALLBACK_SOM_ABS:
+        op->type = SOM_EXTERNAL_CALLBACK_ABS;
+        break;
+    case EXTERNAL_CALLBACK_SOM_REV_NFA:
+        op->type = SOM_EXTERNAL_CALLBACK_REV_NFA;
+        break;
+    case INTERNAL_SOM_LOC_SET_FROM:
+        op->type = SOM_INTERNAL_LOC_SET_FROM;
+        break;
+    case INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE:
+        op->type = SOM_INTERNAL_LOC_SET_FROM_IF_WRITABLE;
+        break;
+    default:
+        // This report doesn't correspond to a SOM operation.
+        assert(0);
+        throw CompileError("Unable to generate bytecode.");
+    }
+
+    op->onmatch = report.onmatch;
+
+    switch (report.type) {
+    case EXTERNAL_CALLBACK_SOM_REV_NFA:
+    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA:
+    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET:
+    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE:
+        op->aux.revNfaIndex = report.revNfaIndex;
+        break;
+    default:
+        op->aux.somDistance = report.somDistance;
+        break;
+    }
+}
+
+static
+void makeReport(RoseBuildImpl &build, const ReportID id,
+                const bool has_som, vector<RoseInstruction> &program) {
+    assert(id < build.rm.numReports());
+    const Report &report = build.rm.getReport(id);
+
+    vector<RoseInstruction> report_block;
+
+    // Handle min/max offset checks.
+    if (report.minOffset > 0 || report.maxOffset < MAX_OFFSET) {
+        auto ri = RoseInstruction(ROSE_INSTR_CHECK_BOUNDS,
+                                  JumpTarget::NEXT_BLOCK);
+        ri.u.checkBounds.min_bound = report.minOffset;
+        ri.u.checkBounds.max_bound = report.maxOffset;
+        report_block.push_back(move(ri));
+    }
+
+    // If this report has an exhaustion key, we can check it in the program
+    // rather than waiting until we're in the callback adaptor.
+    if (report.ekey != INVALID_EKEY) {
+        auto ri = RoseInstruction(ROSE_INSTR_CHECK_EXHAUSTED,
+                                  JumpTarget::NEXT_BLOCK);
+        ri.u.checkExhausted.ekey = report.ekey;
+        report_block.push_back(move(ri));
+    }
+
+    // External SOM reports that aren't passthrough need their SOM value
+    // calculated.
+    if (isExternalSomReport(report) &&
+        report.type != EXTERNAL_CALLBACK_SOM_PASS) {
+        auto ri = RoseInstruction(ROSE_INSTR_SOM_FROM_REPORT);
+        writeSomOperation(report, &ri.u.somFromReport.som);
+        report_block.push_back(move(ri));
+    }
+
+    // Min length constraint.
+    if (report.minLength > 0) {
+        assert(build.hasSom);
+        auto ri = RoseInstruction(ROSE_INSTR_CHECK_MIN_LENGTH,
+                                  JumpTarget::NEXT_BLOCK);
+        ri.u.checkMinLength.end_adj = report.offsetAdjust;
+        ri.u.checkMinLength.min_length = report.minLength;
+        report_block.push_back(move(ri));
+    }
+
+    if (report.quashSom) {
+        report_block.emplace_back(ROSE_INSTR_SOM_ZERO);
+    }
+
+    switch (report.type) {
+    case EXTERNAL_CALLBACK:
+        if (!has_som) {
+            // Dedupe is only necessary if this report has a dkey, or if there
+            // are SOM reports to catch up.
+            bool needs_dedupe = build.rm.getDkey(report) != ~0U || build.hasSom;
+            if (report.ekey == INVALID_EKEY) {
+                if (needs_dedupe) {
+                    report_block.emplace_back(ROSE_INSTR_DEDUPE_AND_REPORT,
+                                              JumpTarget::NEXT_BLOCK);
+                    auto &ri = report_block.back();
+                    ri.u.dedupeAndReport.quash_som = report.quashSom;
+                    ri.u.dedupeAndReport.dkey = build.rm.getDkey(report);
+                    ri.u.dedupeAndReport.onmatch = report.onmatch;
+                    ri.u.dedupeAndReport.offset_adjust = report.offsetAdjust;
+                } else {
+                    report_block.emplace_back(ROSE_INSTR_REPORT);
+                    auto &ri = report_block.back();
+                    ri.u.report.onmatch = report.onmatch;
+                    ri.u.report.offset_adjust = report.offsetAdjust;
+                }
+            } else {
+                if (needs_dedupe) {
+                    makeDedupe(build, report, report_block);
+                }
+                report_block.emplace_back(ROSE_INSTR_REPORT_EXHAUST);
+                auto &ri = report_block.back();
+                ri.u.reportExhaust.onmatch = report.onmatch;
+                ri.u.reportExhaust.offset_adjust = report.offsetAdjust;
+                ri.u.reportExhaust.ekey = report.ekey;
+            }
+        } else { // has_som
+            makeDedupeSom(build, report, report_block);
+            if (report.ekey == INVALID_EKEY) {
+                report_block.emplace_back(ROSE_INSTR_REPORT_SOM);
+                auto &ri = report_block.back();
+                ri.u.reportSom.onmatch = report.onmatch;
+                ri.u.reportSom.offset_adjust = report.offsetAdjust;
+            } else {
+                report_block.emplace_back(ROSE_INSTR_REPORT_SOM_EXHAUST);
+                auto &ri = report_block.back();
+                ri.u.reportSomExhaust.onmatch = report.onmatch;
+                ri.u.reportSomExhaust.offset_adjust = report.offsetAdjust;
+                ri.u.reportSomExhaust.ekey = report.ekey;
             }
         }
+        break;
+    case INTERNAL_SOM_LOC_SET:
+    case INTERNAL_SOM_LOC_SET_IF_UNSET:
+    case INTERNAL_SOM_LOC_SET_IF_WRITABLE:
+    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA:
+    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET:
+    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE:
+    case INTERNAL_SOM_LOC_COPY:
+    case INTERNAL_SOM_LOC_COPY_IF_WRITABLE:
+    case INTERNAL_SOM_LOC_MAKE_WRITABLE:
+    case INTERNAL_SOM_LOC_SET_FROM:
+    case INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE:
+        if (has_som) {
+            report_block.emplace_back(ROSE_INSTR_REPORT_SOM_AWARE);
+            auto &ri = report_block.back();
+            writeSomOperation(report, &ri.u.reportSomAware.som);
+        } else {
+            report_block.emplace_back(ROSE_INSTR_REPORT_SOM_INT);
+            auto &ri = report_block.back();
+            writeSomOperation(report, &ri.u.reportSomInt.som);
+        }
+        break;
+    case INTERNAL_ROSE_CHAIN: {
+        report_block.emplace_back(ROSE_INSTR_REPORT_CHAIN);
+        auto &ri = report_block.back();
+        ri.u.reportChain.event = report.onmatch;
+        ri.u.reportChain.top_squash_distance = report.topSquashDistance;
+        break;
+    }
+    case EXTERNAL_CALLBACK_SOM_REL:
+    case EXTERNAL_CALLBACK_SOM_STORED:
+    case EXTERNAL_CALLBACK_SOM_ABS:
+    case EXTERNAL_CALLBACK_SOM_REV_NFA:
+        makeDedupeSom(build, report, report_block);
+        if (report.ekey == INVALID_EKEY) {
+            report_block.emplace_back(ROSE_INSTR_REPORT_SOM);
+            auto &ri = report_block.back();
+            ri.u.reportSom.onmatch = report.onmatch;
+            ri.u.reportSom.offset_adjust = report.offsetAdjust;
+        } else {
+            report_block.emplace_back(ROSE_INSTR_REPORT_SOM_EXHAUST);
+            auto &ri = report_block.back();
+            ri.u.reportSomExhaust.onmatch = report.onmatch;
+            ri.u.reportSomExhaust.offset_adjust = report.offsetAdjust;
+            ri.u.reportSomExhaust.ekey = report.ekey;
+        }
+        break;
+    case EXTERNAL_CALLBACK_SOM_PASS:
+        makeDedupeSom(build, report, report_block);
+        if (report.ekey == INVALID_EKEY) {
+            report_block.emplace_back(ROSE_INSTR_REPORT_SOM);
+            auto &ri = report_block.back();
+            ri.u.reportSom.onmatch = report.onmatch;
+            ri.u.reportSom.offset_adjust = report.offsetAdjust;
+        } else {
+            report_block.emplace_back(ROSE_INSTR_REPORT_SOM_EXHAUST);
+            auto &ri = report_block.back();
+            ri.u.reportSomExhaust.onmatch = report.onmatch;
+            ri.u.reportSomExhaust.offset_adjust = report.offsetAdjust;
+            ri.u.reportSomExhaust.ekey = report.ekey;
+        }
+        break;
+
+    default:
+        assert(0);
+        throw CompileError("Unable to generate bytecode.");
     }
 
-    return false;
+    assert(!report_block.empty());
+    report_block = flattenProgram({report_block});
+    assert(report_block.back().code() == ROSE_INSTR_END);
+    report_block.pop_back();
+    insert(&program, program.end(), report_block);
 }
 
 static
-void createLiteralEntry(const RoseBuildImpl &tbi, build_context &bc,
-                        vector<RoseLiteral> &literalTable) {
-    const u32 final_id = verify_u32(literalTable.size());
-    assert(contains(tbi.final_id_to_literal, final_id));
-    const u32 literalId = *tbi.final_id_to_literal.at(final_id).begin();
-    /* all literal ids associated with this final id should result in identical
-     * literal entry */
-    const auto &lit_infos = getLiteralInfoByFinalId(tbi, final_id);
-    const rose_literal_info &arb_lit_info = **lit_infos.begin();
-    const auto &vertices = arb_lit_info.vertices;
-
-    literalTable.push_back(RoseLiteral());
-    RoseLiteral &tl = literalTable.back();
-    memset(&tl, 0, sizeof(tl));
-
-    // These two are set by buildRootRoleTable.
-    tl.rootRoleOffset = 0;
-    tl.rootRoleCount = 0;
-
-    tl.groups = 0;
-    for (const auto &li : lit_infos) {
-        tl.groups |= li->group_mask;
-    }
-
-    assert(tl.groups || tbi.literals.right.at(literalId).table == ROSE_ANCHORED
-           || tbi.literals.right.at(literalId).table == ROSE_EVENT);
-
-    // Minimum depth based on this literal's roles.
-    tl.minDepth = calcMinDepth(bc.depths, vertices);
-
-    DEBUG_PRINTF("lit %u: role minDepth=%u\n", final_id, tl.minDepth);
-
-    // If this literal squashes its group behind it, store that data too
-    tl.squashesGroup = arb_lit_info.squash_group;
-
-    // Setup the delay stuff
-    const auto &children = arb_lit_info.delayed_ids;
-    if (children.empty()) {
-        tl.delay_mask = 0;
-        tl.delayIdsOffset = ROSE_OFFSET_INVALID;
-    } else {
-        map<u32, u32> local_delay_map; // delay -> relative child id
-        for (const auto &int_id : children) {
-            const rose_literal_id &child_literal = tbi.literals.right.at(int_id);
-            u32 child_id = tbi.literal_info[int_id].final_id;
-            u32 delay_index = child_id - tbi.delay_base_id;
-            tl.delay_mask |= 1U << child_literal.delay;
-            local_delay_map[child_literal.delay] = delay_index;
-        }
-
-        vector<u32> delayIds;
-        for (const auto &did : local_delay_map | map_values) {
-            delayIds.push_back(did);
-        }
-
-        tl.delayIdsOffset = add_to_engine_blob(bc, delayIds.begin(),
-                                               delayIds.end());
-
-    }
-
-    assert(!tbi.literals.right.at(literalId).delay || !tl.delay_mask);
-
-    tl.requires_side = needsSidecarCatchup(tbi, literalId);
-}
-
-// Construct the literal table.
-static
-void buildLiteralTable(const RoseBuildImpl &tbi, build_context &bc,
-                       vector<RoseLiteral> &literalTable) {
-    size_t numLiterals = tbi.final_id_to_literal.size();
-    literalTable.reserve(numLiterals);
-
-    for (size_t i = 0; i < numLiterals; ++i) {
-        createLiteralEntry(tbi, bc, literalTable);
-    }
-}
-
-static
-void createRoleEntry(RoseBuildImpl &tbi, build_context &bc,
-                     RoseVertex v, vector<RoseRole> &roleTable,
-            ue2::unordered_map<vector<LookEntry>, size_t> &lookaround_cache,
-            u32 *nextStateIndex) {
-    RoseGraph &g = tbi.g;
-
-    // Vertices have been normalised by now to have <= 1 reports.
-    assert(g[v].reports.size() <= 1);
-
-    // set role ID in the graph where we can find it later
-    u32 roleId = (u32)roleTable.size();
-    g[v].role = roleId;
-    // track id if it's a nonroot role for use in buildSparseIter
-    if (!tbi.isRootSuccessor(v)) {
-        for (const auto &lit_id : g[v].literals) {
-            u32 final_id = tbi.literal_info.at(lit_id).final_id;
-            bc.litNonRootRoles[final_id].insert(roleId);
-        }
-    }
-
-    roleTable.push_back(RoseRole());
-    RoseRole &tr = roleTable.back();
-    memset(&tr, 0, sizeof(tr));
-
-    DEBUG_PRINTF("creating role %u for i%zu, eod %u, s (%p,%p)\n", roleId,
-                 g[v].idx, (u32)g[v].eod_accept, g[v].suffix.graph.get(),
-                 g[v].suffix.haig.get());
-
-    // accept roles get their report ID.
-    if (!g[v].reports.empty()) {
-        DEBUG_PRINTF("%zu reports\n", g[v].reports.size());
-        assert(g[v].reports.size() == 1);
-        tr.reportId = *g[v].reports.begin();
-        assert(tr.reportId < tbi.rm.numReports());
-        const Report &ir = tbi.rm.getReport(tr.reportId);
-        if (isInternalSomReport(ir)) {
-            tr.flags |= ROSE_ROLE_FLAG_SOM_REPORT;
-        }
-        if (ir.type == INTERNAL_ROSE_CHAIN) {
-            tr.flags |= ROSE_ROLE_FLAG_CHAIN_REPORT;
-        }
-    } else {
-        tr.reportId = MO_INVALID_IDX;
-    }
-
-    tr.leftfixReport = g[v].left.leftfix_report;
-    assert(!tbi.cc.streaming || g[v].left.lag <= MAX_STORED_LEFTFIX_LAG);
-    tr.leftfixLag = g[v].left.lag;
-    tr.depth = (u8)min(254U, bc.depths.at(v));
-    tr.groups = g[v].groups;
-    tr.flags |= ROSE_ROLE_PRED_NONE;
-
-    if (contains(bc.leftfix_info, v)) {
-        const left_build_info &lni = bc.leftfix_info.at(v);
-        if (!lni.has_lookaround) {
-            tr.flags |= ROSE_ROLE_FLAG_ROSE;
-            tr.leftfixQueue = lni.nfa->queueIndex;
-        }
-    }
-
-    if (!g[v].literals.empty()) {
-        /* all literals for a role come from the same table -> inspect any */
-        switch (tbi.literals.right.at(*g[v].literals.begin()).table) {
-        case ROSE_ANCHORED:
-            tr.flags |= ROSE_ROLE_FLAG_ANCHOR_TABLE;
-            break;
-        case ROSE_EOD_ANCHORED:
-            tr.flags |= ROSE_ROLE_FLAG_EOD_TABLE;
-            break;
-        default:
-            ;
-        }
-    }
-
-    // Leaf nodes don't need state indices, as they don't have successors.
-    /* TODO: also don't need a state index if all edges are nfa based */
-    if (isLeafNode(v, g)) {
-        tr.stateIndex = MMB_INVALID;
-    } else {
-        tr.stateIndex = (*nextStateIndex)++;
-    }
+void makeRoleReports(RoseBuildImpl &build, build_context &bc, RoseVertex v,
+                     vector<RoseInstruction> &program) {
+    const auto &g = build.g;
 
     /* we are a suffaig - need to update role to provide som to the
      * suffix. */
     bool has_som = false;
     if (g[v].left.tracksSom()) {
-        tr.flags |= ROSE_ROLE_FLAG_SOM_ROSEFIX;
+        assert(contains(bc.leftfix_info, v));
+        const left_build_info &lni = bc.leftfix_info.at(v);
+        auto ri = RoseInstruction(ROSE_INSTR_SOM_LEFTFIX);
+        ri.u.somLeftfix.queue = lni.queue;
+        ri.u.somLeftfix.lag = g[v].left.lag;
+        program.push_back(ri);
         has_som = true;
     } else if (g[v].som_adjust) {
-        tr.somAdjust = g[v].som_adjust;
-        tr.flags |= ROSE_ROLE_FLAG_SOM_ADJUST;
+        auto ri = RoseInstruction(ROSE_INSTR_SOM_ADJUST);
+        ri.u.somAdjust.distance = g[v].som_adjust;
+        program.push_back(ri);
         has_som = true;
     }
 
-    if (has_som && !g[v].reports.empty()) {
-        tr.flags |= ROSE_ROLE_FLAG_REPORT_START;
-    }
+    const auto &reports = g[v].reports;
+    makeCatchup(build, bc, reports, program);
 
-    vector<LookEntry> look;
-    if (tbi.cc.grey.roseLookaroundMasks) {
-        // Lookaround from leftfix (mandatory).
-        if (contains(bc.leftfix_info, v) &&
-            bc.leftfix_info.at(v).has_lookaround) {
-            DEBUG_PRINTF("using leftfix lookaround\n");
-            look = bc.leftfix_info.at(v).lookaround;
-        }
-        // We may be able to find more lookaround info (advisory) and merge it
-        // in.
-        vector<LookEntry> look_more;
-        findLookaroundMasks(tbi, v, look_more);
-        mergeLookaround(look, look_more);
+    for (ReportID id : reports) {
+        makeReport(build, id, has_som, program);
     }
-    if (look.empty()) {
-        DEBUG_PRINTF("no lookaround\n");
-        tr.lookaroundIndex = MO_INVALID_IDX;
-        tr.lookaroundCount = 0;
+}
+
+static
+void makeRoleSuffix(RoseBuildImpl &build, build_context &bc, RoseVertex v,
+                    vector<RoseInstruction> &program) {
+    const auto &g = build.g;
+    if (!g[v].suffix) {
+        return;
+    }
+    assert(contains(bc.suffixes, g[v].suffix));
+    u32 qi = bc.suffixes.at(g[v].suffix);
+    assert(contains(bc.engineOffsets, qi));
+    const NFA *nfa = get_nfa_from_blob(bc, qi);
+    u32 suffixEvent;
+    if (isMultiTopType(nfa->type)) {
+        assert(!g[v].suffix.haig);
+        u32 top = (u32)MQE_TOP_FIRST + g[v].suffix.top;
+        assert(top < MQE_INVALID);
+        suffixEvent = top;
     } else {
-        auto it = lookaround_cache.find(look);
-        if (it != lookaround_cache.end()) {
-            DEBUG_PRINTF("reusing look at idx %zu\n", it->second);
-            tr.lookaroundIndex = verify_u32(it->second);
+        // DFAs/Puffs have no MQE_TOP_N support, so they get a classic TOP
+        // event.
+        assert(!g[v].suffix.graph || onlyOneTop(*g[v].suffix.graph));
+        suffixEvent = MQE_TOP;
+    }
+    auto ri = RoseInstruction(ROSE_INSTR_TRIGGER_SUFFIX);
+    ri.u.triggerSuffix.queue = qi;
+    ri.u.triggerSuffix.event = suffixEvent;
+    program.push_back(ri);
+}
+
+static
+void makeRoleGroups(const rose_group &groups,
+                    vector<RoseInstruction> &program) {
+    if (!groups) {
+        return;
+    }
+    auto ri = RoseInstruction(ROSE_INSTR_SET_GROUPS);
+    ri.u.setGroups.groups = groups;
+    program.push_back(ri);
+}
+
+static
+void makeRoleInfixTriggers(RoseBuildImpl &build, build_context &bc,
+                           RoseVertex u, vector<RoseInstruction> &program) {
+    const auto &g = build.g;
+
+    vector<RoseInstruction> infix_program;
+
+    for (const auto &e : out_edges_range(u, g)) {
+        RoseVertex v = target(e, g);
+        if (!g[v].left) {
+            continue;
+        }
+
+        assert(contains(bc.leftfix_info, v));
+        const left_build_info &lbi = bc.leftfix_info.at(v);
+        if (lbi.has_lookaround) {
+            continue;
+        }
+
+        const NFA *nfa = get_nfa_from_blob(bc, lbi.queue);
+
+        // DFAs have no TOP_N support, so they get a classic MQE_TOP event.
+        u32 top;
+        if (!isMultiTopType(nfa->type)) {
+            assert(num_tops(g[v].left) == 1);
+            top = MQE_TOP;
         } else {
-            size_t idx = bc.lookaround.size();
-            lookaround_cache.insert(make_pair(look, idx));
-            insert(&bc.lookaround, bc.lookaround.end(), look);
-            DEBUG_PRINTF("adding look at idx %zu\n", idx);
-            tr.lookaroundIndex = verify_u32(idx);
+            top = MQE_TOP_FIRST + g[e].rose_top;
+            assert(top < MQE_INVALID);
         }
-        tr.lookaroundCount = verify_u32(look.size());
+
+        auto ri = RoseInstruction(ROSE_INSTR_TRIGGER_INFIX);
+        ri.u.triggerInfix.queue = lbi.queue;
+        ri.u.triggerInfix.event = top;
+        ri.u.triggerInfix.cancel = g[e].rose_cancel_prev_top;
+        infix_program.push_back(ri);
     }
 
-    DEBUG_PRINTF("role id=%u, stateidx=%u, reportId=%u, "
-                 "depth=%u, groups=0x%016llx\n", roleId, tr.stateIndex,
-                 tr.reportId, tr.depth, tr.groups);
+    if (infix_program.empty()) {
+        return;
+    }
+
+    // Order, de-dupe and add instructions to the end of program.
+    sort(begin(infix_program), end(infix_program));
+    unique_copy(begin(infix_program), end(infix_program),
+                back_inserter(program));
 }
 
-// Construct an initial role table containing the basic role information.
 static
-void buildInitialRoleTable(RoseBuildImpl &tbi, build_context &bc) {
-    DEBUG_PRINTF("building role table\n");
-
-    const RoseGraph &g = tbi.g;
-    vector<RoseRole> &roleTable = bc.roleTable;
-
-    // Create a list of vertices, ordered by depth.
-    vector<RoseVertex> verts;
-    insert(&verts, verts.end(), vertices(g));
-    sort(begin(verts), end(verts), [&bc, &g](const RoseVertex &a,
-                                             const RoseVertex &b) {
-        return tie(bc.depths.at(a), g[a].idx) < tie(bc.depths.at(b), g[b].idx);
-    });
-
-    // LookEntry list cache, so that we don't have to go scanning through the
-    // full list to find cases we've used already.
-    ue2::unordered_map<vector<LookEntry>, size_t> lookaround_cache;
-
-    // Write a role entry for every vertex that represents a real literal.
-    // Direct reports are skipped.
-    // We start the state indices from one after the last one used (on the
-    // anchored root, if it exists).
-    u32 stateIndex = verify_u32(roleTable.size());
-
-    for (RoseVertex v : verts) {
-        if (tbi.isVirtualVertex(v)) {
-            DEBUG_PRINTF("vertex idx=%zu is virtual\n", g[v].idx);
-            continue;
-        }
-        if (tbi.hasDirectFinalId(v)) {
-            DEBUG_PRINTF("vertex idx=%zu is direct report\n", g[v].idx);
-            continue;
-        }
-
-        assert(!g[v].literals.empty());
-        createRoleEntry(tbi, bc, v, roleTable, lookaround_cache, &stateIndex);
+void makeRoleSetState(const build_context &bc, RoseVertex v,
+                      vector<RoseInstruction> &program) {
+    // We only need this instruction if a state index has been assigned to this
+    // vertex.
+    auto it = bc.roleStateIndices.find(v);
+    if (it == end(bc.roleStateIndices)) {
+        return;
     }
 
-    bc.numStates = stateIndex;
-    DEBUG_PRINTF("wrote %zu roles with %u states\n", roleTable.size(),
-                 stateIndex);
+    u32 idx = it->second;
+    auto ri = RoseInstruction(ROSE_INSTR_SET_STATE);
+    ri.u.setState.index = idx;
+    program.push_back(ri);
 }
 
-// Construct pred table and sparse iterators over preds.
 static
-void buildPredTable(const RoseBuildImpl &tbi, build_context &bc,
-                    vector<RosePred> &predTable) {
-    const RoseGraph &g = tbi.g;
+void makeRoleCheckBounds(const RoseBuildImpl &build, RoseVertex v,
+                         const RoseEdge &e, vector<RoseInstruction> &program) {
+    const RoseGraph &g = build.g;
+    const RoseVertex u = source(e, g);
 
-    // We write our preds out in role index order just to give things some
-    // repeatability.
-    vector<RoseVertex> verts = get_ordered_verts(g);
+    // We know that we can trust the anchored table (DFA) to always deliver us
+    // literals at the correct offset.
+    if (build.isAnchored(v)) {
+        DEBUG_PRINTF("literal in anchored table, skipping bounds check\n");
+        return;
+    }
 
-    for (RoseVertex v : verts) {
-        if (tbi.isAnyStart(v) || g[v].role == MO_INVALID_IDX) {
+    // Use the minimum literal length.
+    u32 lit_length = g[v].eod_accept ? 0 : verify_u32(build.minLiteralLen(v));
+
+    u64a min_bound = g[e].minBound + lit_length;
+    u64a max_bound = g[e].maxBound == ROSE_BOUND_INF
+                         ? ROSE_BOUND_INF
+                         : g[e].maxBound + lit_length;
+
+    if (g[e].history == ROSE_ROLE_HISTORY_ANCH) {
+        assert(g[u].max_offset != ROSE_BOUND_INF);
+        // Make offsets absolute.
+        min_bound += g[u].max_offset;
+        if (max_bound != ROSE_BOUND_INF) {
+            max_bound += g[u].max_offset;
+        }
+    }
+
+    assert(max_bound <= ROSE_BOUND_INF);
+    assert(min_bound <= max_bound);
+
+    // CHECK_BOUNDS instruction uses 64-bit bounds, so we can use MAX_OFFSET
+    // (max value of a u64a) to represent ROSE_BOUND_INF.
+    if (max_bound == ROSE_BOUND_INF) {
+        max_bound = MAX_OFFSET;
+    }
+
+    auto ri = RoseInstruction(ROSE_INSTR_CHECK_BOUNDS, JumpTarget::NEXT_BLOCK);
+    ri.u.checkBounds.min_bound = min_bound;
+    ri.u.checkBounds.max_bound = max_bound;
+
+    program.push_back(move(ri));
+}
+
+static
+void makeRoleCheckNotHandled(build_context &bc, RoseVertex v,
+                             vector<RoseInstruction> &program) {
+    auto ri = RoseInstruction(ROSE_INSTR_CHECK_NOT_HANDLED,
+                              JumpTarget::NEXT_BLOCK);
+
+    u32 handled_key;
+    if (contains(bc.handledKeys, v)) {
+        handled_key = bc.handledKeys.at(v);
+    } else {
+        handled_key = verify_u32(bc.handledKeys.size());
+        bc.handledKeys.emplace(v, handled_key);
+    }
+
+    ri.u.checkNotHandled.key = handled_key;
+
+    program.push_back(move(ri));
+}
+
+static
+vector<RoseInstruction> makeProgram(RoseBuildImpl &build, build_context &bc,
+                                    const RoseEdge &e) {
+    const RoseGraph &g = build.g;
+    auto v = target(e, g);
+
+    vector<RoseInstruction> program;
+
+    // First, add program instructions that enforce preconditions without
+    // effects.
+
+    makeRoleAnchoredDelay(build, bc, v, program);
+
+    if (onlyAtEod(build, v)) {
+        DEBUG_PRINTF("only at eod\n");
+        program.push_back(RoseInstruction(ROSE_INSTR_CHECK_ONLY_EOD,
+                                          JumpTarget::NEXT_BLOCK));
+    }
+
+    if (g[e].history == ROSE_ROLE_HISTORY_ANCH) {
+        makeRoleCheckBounds(build, v, e, program);
+    }
+
+    // This program may be triggered by different predecessors, with different
+    // offset bounds. We must ensure we put this check/set operation after the
+    // bounds check to deal with this case.
+    if (hasGreaterInDegree(1, v, g)) {
+        makeRoleCheckNotHandled(bc, v, program);
+    }
+
+    makeRoleLookaround(build, bc, v, program);
+    makeRoleCheckLeftfix(build, bc, v, program);
+
+    // Next, we can add program instructions that have effects.
+
+    makeRoleReports(build, bc, v, program);
+    makeRoleInfixTriggers(build, bc, v, program);
+
+    // Note: SET_GROUPS instruction must be after infix triggers, as an infix
+    // going dead may switch off groups.
+    makeRoleGroups(g[v].groups, program);
+
+    makeRoleSuffix(build, bc, v, program);
+    makeRoleSetState(bc, v, program);
+
+    return program;
+}
+
+static
+u32 writeBoundaryProgram(RoseBuildImpl &build, build_context &bc,
+                         const set<ReportID> &reports) {
+    if (reports.empty()) {
+        return 0;
+    }
+
+    // Note: no CATCHUP instruction is necessary in the boundary case, as we
+    // should always be caught up (and may not even have the resources in
+    // scratch to support it).
+
+    const bool has_som = false;
+    vector<RoseInstruction> program;
+    for (const auto &id : reports) {
+        makeReport(build, id, has_som, program);
+    }
+    program = flattenProgram({program});
+    applyFinalSpecialisation(program);
+    return writeProgram(bc, program);
+}
+
+static
+RoseBoundaryReports
+makeBoundaryPrograms(RoseBuildImpl &build, build_context &bc,
+                     const BoundaryReports &boundary,
+                     const DerivedBoundaryReports &dboundary) {
+    RoseBoundaryReports out;
+    memset(&out, 0, sizeof(out));
+
+    DEBUG_PRINTF("report ^:  %zu\n", boundary.report_at_0.size());
+    DEBUG_PRINTF("report $:  %zu\n", boundary.report_at_eod.size());
+    DEBUG_PRINTF("report ^$: %zu\n", dboundary.report_at_0_eod_full.size());
+
+    out.reportEodOffset =
+        writeBoundaryProgram(build, bc, boundary.report_at_eod);
+    out.reportZeroOffset =
+        writeBoundaryProgram(build, bc, boundary.report_at_0);
+    out.reportZeroEodOffset =
+        writeBoundaryProgram(build, bc, dboundary.report_at_0_eod_full);
+
+    return out;
+}
+
+static
+void assignStateIndices(const RoseBuildImpl &build, build_context &bc) {
+    const auto &g = build.g;
+
+    u32 state = 0;
+
+    for (auto v : vertices_range(g)) {
+        // Virtual vertices (starts, EOD accept vertices) never need state
+        // indices.
+        if (build.isVirtualVertex(v)) {
             continue;
         }
-
-        assert(g[v].role < bc.roleTable.size());
-        RoseRole &tr = bc.roleTable.at(g[v].role);
-
-        // Assumption: if a vertex is a root role, it must have only one
-        // predecessor.
-        assert(!tbi.isRootSuccessor(v) || in_degree(v, g) == 1);
-
-        // Check if we can use a "simple" check, i.e. one pred, bounds [0,
-        // inf], no overlap and not anchor->float transition.
-        if (in_degree(v, g) == 1) {
-            const RoseEdge &e = *in_edges(v, g).first;
-            RoseVertex u = source(e, g);
-            DEBUG_PRINTF("single edge: (role=%u)->(role=%u) with bounds "
-                         "[%u, %u]\n", g[u].role, g[v].role, g[e].minBound,
-                         g[e].maxBound);
-            if (tbi.isAnyStart(u)) {
-                /* we have ourselves a root role */
-                assert(u != tbi.root || g[e].maxBound == ROSE_BOUND_INF);
-                if (u == tbi.root && g[e].minBound == 0) {
-                    DEBUG_PRINTF("root role with .* edge, no pred needed\n");
-                    continue; /* no pred required */
-                }
-                tr.predOffset = verify_u32(predTable.size());
-                tr.flags &= ROSE_ROLE_PRED_CLEAR_MASK;
-                tr.flags |= ROSE_ROLE_PRED_ROOT;
-                createPred(tbi, bc, e, predTable);
-                continue;
-            }
-
-            assert(!g[u].literals.empty() && !g[v].literals.empty());
-            bool pseudo_delay_history = true;
-            for (u32 ul : g[u].literals) {
-                pseudo_delay_history = !!tbi.literals.right.at(ul).delay;
-            }
-            if (!pseudo_delay_history) {
-                DEBUG_PRINTF("max_overlap = %zu\n",
-                             tbi.maxLiteralOverlap(u, v));
-            }
-            if (g[e].minBound == 0 && g[e].maxBound == ROSE_BOUND_INF
-                && (pseudo_delay_history || !tbi.maxLiteralOverlap(u, v))) {
-                tr.flags &= ROSE_ROLE_PRED_CLEAR_MASK;
-                tr.flags |= ROSE_ROLE_PRED_SIMPLE;
-                bc.rolePredecessors[g[v].role].push_back(g[u].role);
-                continue;
-            }
+        // Leaf nodes don't need state indices, as they don't have successors.
+        if (isLeafNode(v, g)) {
+            continue;
         }
-
-        assert(in_degree(v, g) >= 1);
-        tr.flags &= ROSE_ROLE_PRED_CLEAR_MASK;
-        tr.flags |= ROSE_ROLE_PRED_ANY;
-
-        // Collect in-edges, ordered by the state index of the predecessor.
-        vector<RoseEdge> edges = make_vector_from(in_edges(v, g));
-        sort(edges.begin(), edges.end(),
-             EdgeSourceStateCompare(g, bc.roleTable));
-
-        vector<u32> keys;
-
-        // Create preds and collect state indices for our sparse iterator.
-        for (const auto &e : edges) {
-            createPred(tbi, bc, e, predTable);
-            RoseVertex u = source(e, g);
-            assert(g[u].role < bc.roleTable.size());
-            u32 stateIdx = bc.roleTable.at(g[u].role).stateIndex;
-            if (stateIdx != MMB_INVALID) {
-                keys.push_back(stateIdx);
-            }
-        }
-
-        vector<mmbit_sparse_iter> iter;
-        mmbBuildSparseIterator(iter, keys, bc.numStates);
-        assert(!iter.empty());
-
-        tr.predOffset = addIteratorToTable(bc, iter);
+        /* TODO: also don't need a state index if all edges are nfa based */
+        bc.roleStateIndices.emplace(v, state++);
     }
+
+    DEBUG_PRINTF("assigned %u states (from %zu vertices)\n", state,
+                 num_vertices(g));
+    bc.numStates = state;
 }
 
 static
@@ -3589,8 +3172,7 @@ void buildLeftInfoTable(const RoseBuildImpl &tbi, build_context &bc,
 
     u32 lagIndex = 0;
 
-    vector<RoseVertex> verts = get_ordered_verts(g);
-    for (RoseVertex v : verts) {
+    for (RoseVertex v : vertices_range(g)) {
         if (!g[v].left) {
             continue;
         }
@@ -3600,9 +3182,8 @@ void buildLeftInfoTable(const RoseBuildImpl &tbi, build_context &bc,
             continue;
         }
 
-        assert(lbi.nfa);
-        assert(lbi.nfa->queueIndex >= leftfixBeginQueue);
-        u32 left_index = lbi.nfa->queueIndex - leftfixBeginQueue;
+        assert(lbi.queue >= leftfixBeginQueue);
+        u32 left_index = lbi.queue - leftfixBeginQueue;
         assert(left_index < leftfixCount);
 
         /* seedy hack to make miracles more effective.
@@ -3667,77 +3248,623 @@ void buildLeftInfoTable(const RoseBuildImpl &tbi, build_context &bc,
     *laggedRoseCount = lagIndex;
 }
 
-// Build sparse iterators for literals.
 static
-void buildSparseIter(build_context &bc, vector<RoseLiteral> &literalTable,
-                     const vector<RosePred> &predTable) {
-    for (u32 finalId = 0; finalId != literalTable.size(); ++finalId) {
-        RoseLiteral &tl = literalTable[finalId];
+u32 addPredBlocksSingle(
+    map<u32, vector<vector<RoseInstruction>>> &predProgramLists,
+    vector<RoseInstruction> &program) {
 
-        if (!contains(bc.litNonRootRoles, finalId)) {
-            // This literal has no nonroot roles => no sparse iter
-            tl.iterOffset = ROSE_OFFSET_INVALID;
-            tl.iterMapOffset = ROSE_OFFSET_INVALID;
-            continue;
+    vector<vector<RoseInstruction>> prog_blocks;
+
+    for (const auto &m : predProgramLists) {
+        const u32 &pred_state = m.first;
+        auto subprog = flattenProgram(m.second);
+
+        // Check our pred state.
+        auto ri = RoseInstruction(ROSE_INSTR_CHECK_STATE,
+                                  JumpTarget::NEXT_BLOCK);
+        ri.u.checkState.index = pred_state;
+        subprog.insert(begin(subprog), ri);
+        assert(subprog.back().code() == ROSE_INSTR_END);
+        subprog.pop_back();
+        prog_blocks.push_back(move(subprog));
+    }
+
+    auto prog = flattenProgram(prog_blocks);
+    program.insert(end(program), begin(prog), end(prog));
+    return 0; // No iterator.
+}
+
+static
+u32 programLength(const vector<RoseInstruction> &program) {
+    u32 len = 0;
+    for (const auto &ri : program) {
+        len += ROUNDUP_N(ri.length(), ROSE_INSTR_MIN_ALIGN);
+    }
+    return len;
+}
+
+static
+u32 addPredBlocksMulti(build_context &bc,
+                    map<u32, vector<vector<RoseInstruction>>> &predProgramLists,
+                    vector<RoseInstruction> &program) {
+    assert(!predProgramLists.empty());
+
+    // First, add the iterator itself.
+    vector<u32> keys;
+    for (const auto &elem : predProgramLists) {
+        keys.push_back(elem.first);
+    }
+    DEBUG_PRINTF("%zu keys: %s\n", keys.size(), as_string_list(keys).c_str());
+
+    vector<mmbit_sparse_iter> iter;
+    mmbBuildSparseIterator(iter, keys, bc.numStates);
+    assert(!iter.empty());
+    u32 iter_offset = addIteratorToTable(bc, iter);
+
+    // Construct our program, starting with the SPARSE_ITER_BEGIN
+    // instruction, keeping track of the jump offset for each sub-program.
+    vector<RoseInstruction> sparse_program;
+    vector<u32> jump_table;
+
+    sparse_program.push_back(RoseInstruction(ROSE_INSTR_SPARSE_ITER_BEGIN,
+                                             JumpTarget::PROGRAM_END));
+    u32 curr_offset = programLength(program) + programLength(sparse_program);
+
+    for (const auto &e : predProgramLists) {
+        DEBUG_PRINTF("subprogram %zu has offset %u\n", jump_table.size(),
+                     curr_offset);
+        jump_table.push_back(curr_offset);
+        auto subprog = flattenProgram(e.second);
+
+        if (e.first != keys.back()) {
+            // For all but the last subprogram, replace the END instruction
+            // with a SPARSE_ITER_NEXT.
+            assert(!subprog.empty());
+            assert(subprog.back().code() == ROSE_INSTR_END);
+            subprog.back() = RoseInstruction(ROSE_INSTR_SPARSE_ITER_NEXT,
+                                             JumpTarget::PROGRAM_END);
         }
 
-        const auto &roles = bc.litNonRootRoles.at(finalId);
-        assert(!roles.empty());
+        curr_offset += programLength(subprog);
+        insert(&sparse_program, end(sparse_program), subprog);
+    }
 
-        // Collect the state IDs of the predecessors of the roles of this
-        // literal.
+    // Strip the END instruction from the last block.
+    assert(sparse_program.back().code() == ROSE_INSTR_END);
+    sparse_program.pop_back();
 
-        // pred state id -> role/pred entries
-        map<u32, vector<RoseIterRole> > predStates;
+    sparse_program = flattenProgram({sparse_program});
 
-        for (u32 r : roles) {
-            const RoseRole &tr = bc.roleTable.at(r);
-            if (tr.flags & ROSE_ROLE_PRED_SIMPLE) {
-                u32 p = bc.rolePredecessors.at(r)[0];
-                assert(p != ROSE_OFFSET_INVALID);
-                RoseIterRole ir = { r, ROSE_OFFSET_INVALID };
-                predStates[bc.roleTable[p].stateIndex].push_back(ir);
-            } else {
-                const vector<u32> &myPreds = bc.rolePredecessors.at(r);
-                for (u32 pred_entry : myPreds) {
-                    u32 p = predTable.at(pred_entry).role;
-                    RoseIterRole ir = { r, pred_entry };
-                    assert(p < bc.roleTable.size());
-                    predStates[bc.roleTable[p].stateIndex].push_back(ir);
-                }
-            }
+    // Write the jump table into the bytecode.
+    const u32 jump_table_offset =
+        add_to_engine_blob(bc, begin(jump_table), end(jump_table));
+
+    // Write jump table and iterator offset into sparse iter instructions.
+    auto keys_it = begin(keys);
+    for (auto &ri : sparse_program) {
+        switch (ri.code()) {
+        case ROSE_INSTR_SPARSE_ITER_BEGIN:
+            ri.u.sparseIterBegin.iter_offset = iter_offset;
+            ri.u.sparseIterBegin.jump_table = jump_table_offset;
+            break;
+        case ROSE_INSTR_SPARSE_ITER_NEXT:
+            ri.u.sparseIterNext.iter_offset = iter_offset;
+            ri.u.sparseIterNext.jump_table = jump_table_offset;
+            assert(keys_it != end(keys));
+            ri.u.sparseIterNext.state = *keys_it++;
+            break;
+        default:
+            break;
         }
+    }
 
-        tie(tl.iterMapOffset, tl.iterOffset) = addPredSparseIter(bc, predStates);
+    program.insert(end(program), begin(sparse_program), end(sparse_program));
+
+    return iter_offset;
+}
+
+static
+u32 addPredBlocks(build_context &bc,
+                  map<u32, vector<vector<RoseInstruction>>> &predProgramLists,
+                  vector<RoseInstruction> &program,
+                  bool force_sparse_iter) {
+    const size_t num_preds = predProgramLists.size();
+    if (num_preds == 0) {
+        program = flattenProgram({program});
+        return 0; // No iterator.
+    } else if (!force_sparse_iter && num_preds == 1) {
+        return addPredBlocksSingle(predProgramLists, program);
+    } else {
+        return addPredBlocksMulti(bc, predProgramLists, program);
+    }
+}
+
+/**
+ * Returns the pair (program offset, sparse iter offset).
+ */
+static
+pair<u32, u32> makeSparseIterProgram(build_context &bc,
+                    map<u32, vector<vector<RoseInstruction>>> &predProgramLists,
+                    const vector<RoseInstruction> &root_program,
+                    const vector<RoseInstruction> &pre_program) {
+    vector<RoseInstruction> program;
+    u32 curr_offset = 0;
+
+    // Add pre-program first.
+    for (const auto &ri : pre_program) {
+        program.push_back(ri);
+        curr_offset += ROUNDUP_N(ri.length(), ROSE_INSTR_MIN_ALIGN);
+    }
+
+    // Add blocks to deal with non-root edges (triggered by sparse iterator or
+    // mmbit_isset checks). This operation will flatten the program up to this
+    // point.
+    u32 iter_offset = addPredBlocks(bc, predProgramLists, program, false);
+
+    // If we have a root program, replace the END instruction with it. Note
+    // that the root program has already been flattened.
+    assert(!program.empty());
+    assert(program.back().code() == ROSE_INSTR_END);
+    if (!root_program.empty()) {
+        program.pop_back();
+        program.insert(end(program), begin(root_program), end(root_program));
+    }
+
+    applyFinalSpecialisation(program);
+    return {writeProgram(bc, program), iter_offset};
+}
+
+static
+void makePushDelayedInstructions(const RoseBuildImpl &build, u32 final_id,
+                                 vector<RoseInstruction> &program) {
+    const auto &lit_infos = getLiteralInfoByFinalId(build, final_id);
+    const auto &arb_lit_info = **lit_infos.begin();
+    if (arb_lit_info.delayed_ids.empty()) {
+        return;
+    }
+
+    for (const auto &int_id : arb_lit_info.delayed_ids) {
+        const auto &child_literal = build.literals.right.at(int_id);
+        u32 child_id = build.literal_info[int_id].final_id;
+        u32 delay_index = child_id - build.delay_base_id;
+
+        DEBUG_PRINTF("final_id=%u delay=%u child_id=%u\n", final_id,
+                     child_literal.delay, child_id);
+
+        auto ri = RoseInstruction(ROSE_INSTR_PUSH_DELAYED);
+        ri.u.pushDelayed.delay = verify_u8(child_literal.delay);
+        ri.u.pushDelayed.index = delay_index;
+        program.push_back(move(ri));
     }
 }
 
 static
-void calcAnchoredMatches(const RoseBuildImpl &build, vector<ReportID> &art,
-                         vector<u32> &arit) {
+void makeGroupCheckInstruction(const RoseBuildImpl &build, u32 final_id,
+                               vector<RoseInstruction> &program) {
+    assert(contains(build.final_id_to_literal, final_id));
+    const auto &lit_infos = getLiteralInfoByFinalId(build, final_id);
+
+    rose_group groups = 0;
+    for (const auto &li : lit_infos) {
+        groups |= li->group_mask;
+    }
+
+    if (!groups) {
+        return;
+    }
+
+    auto ri = RoseInstruction(ROSE_INSTR_CHECK_GROUPS);
+    ri.u.checkGroups.groups = groups;
+    program.push_back(move(ri));
+}
+
+static
+void makeCheckLitMaskInstruction(const RoseBuildImpl &build, u32 final_id,
+                                 vector<RoseInstruction> &program) {
+    assert(contains(build.final_id_to_literal, final_id));
+    const auto &lit_infos = getLiteralInfoByFinalId(build, final_id);
+    assert(!lit_infos.empty());
+
+    if (!lit_infos.front()->requires_benefits) {
+        return;
+    }
+
+    auto ri = RoseInstruction(ROSE_INSTR_CHECK_LIT_MASK);
+
+    assert(build.final_id_to_literal.at(final_id).size() == 1);
+    u32 lit_id = *build.final_id_to_literal.at(final_id).begin();
+    const ue2_literal &s = build.literals.right.at(lit_id).s;
+    DEBUG_PRINTF("building mask for lit %u (final id %u) %s\n", lit_id,
+                 final_id, dumpString(s).c_str());
+    assert(s.length() <= MAX_MASK2_WIDTH);
+    u32 i = 0;
+    for (const auto &e : s) {
+        ri.u.checkLitMask.and_mask.a8[i] = e.nocase ? 0 : CASE_BIT;
+        ri.u.checkLitMask.cmp_mask.a8[i] = e.nocase ? 0 : (CASE_BIT & e.c);
+        i++;
+    }
+
+    program.push_back(move(ri));
+}
+
+static
+void makeGroupSquashInstruction(const RoseBuildImpl &build, u32 final_id,
+                                vector<RoseInstruction> &program) {
+    assert(contains(build.final_id_to_literal, final_id));
+    const auto &lit_infos = getLiteralInfoByFinalId(build, final_id);
+
+    if (!lit_infos.front()->squash_group) {
+        return;
+    }
+
+    rose_group groups = 0;
+    for (const auto &li : lit_infos) {
+        groups |= li->group_mask;
+    }
+
+    if (!groups) {
+        return;
+    }
+
+    DEBUG_PRINTF("final_id %u squashes 0x%llx\n", final_id, groups);
+
+    auto ri = RoseInstruction(ROSE_INSTR_SQUASH_GROUPS);
+    ri.u.squashGroups.groups = ~groups; // Negated, so we can just AND it in.
+    program.push_back(move(ri));
+}
+
+static
+void makeCheckLitEarlyInstruction(const RoseBuildImpl &build, build_context &bc,
+                                  u32 final_id,
+                                  const vector<RoseEdge> &lit_edges,
+                                  vector<RoseInstruction> &program) {
+    if (lit_edges.empty()) {
+        return;
+    }
+
+    if (bc.floatingMinLiteralMatchOffset == 0) {
+        return;
+    }
+
+    RoseVertex v = target(lit_edges.front(), build.g);
+    if (!build.isFloating(v)) {
+        return;
+    }
+
+    const auto &lit_ids = build.final_id_to_literal.at(final_id);
+    if (lit_ids.empty()) {
+        return;
+    }
+
+    size_t min_offset = SIZE_MAX;
+    for (u32 lit_id : lit_ids) {
+        const auto &lit = build.literals.right.at(lit_id);
+        min_offset = min(min_offset, lit.elength());
+    }
+
+    DEBUG_PRINTF("%zu lits, min_offset=%zu\n", lit_ids.size(), min_offset);
+
+    // If we can't match before the min offset, we don't need the check.
+    if (min_offset >= bc.floatingMinLiteralMatchOffset) {
+        DEBUG_PRINTF("no need for check, min is %u\n",
+                      bc.floatingMinLiteralMatchOffset);
+        return;
+    }
+
+    program.push_back(RoseInstruction(ROSE_INSTR_CHECK_LIT_EARLY));
+}
+
+static
+bool hasDelayedLiteral(RoseBuildImpl &build,
+                       const vector<RoseEdge> &lit_edges) {
+    auto is_delayed = bind(&RoseBuildImpl::isDelayed, &build, _1);
+    for (const auto &e : lit_edges) {
+        auto v = target(e, build.g);
+        const auto &lits = build.g[v].literals;
+        if (any_of(begin(lits), end(lits), is_delayed)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static
+vector<RoseInstruction> buildLitInitialProgram(RoseBuildImpl &build,
+                                    build_context &bc, u32 final_id,
+                                    const vector<RoseEdge> &lit_edges) {
+    vector<RoseInstruction> pre_program;
+
+    // No initial program for EOD.
+    if (final_id == MO_INVALID_IDX) {
+        return pre_program;
+    }
+
+    DEBUG_PRINTF("final_id %u\n", final_id);
+
+    // Check lit mask.
+    makeCheckLitMaskInstruction(build, final_id, pre_program);
+
+    // Check literal groups. This is an optimisation that we only perform for
+    // delayed literals, as their groups may be switched off; ordinarily, we
+    // can trust the HWLM matcher.
+    if (hasDelayedLiteral(build, lit_edges)) {
+        makeGroupCheckInstruction(build, final_id, pre_program);
+    }
+
+    // Add instructions for pushing delayed matches, if there are any.
+    makePushDelayedInstructions(build, final_id, pre_program);
+
+    // Add pre-check for early literals in the floating table.
+    makeCheckLitEarlyInstruction(build, bc, final_id, lit_edges, pre_program);
+
+    return pre_program;
+}
+
+static
+u32 buildLiteralProgram(RoseBuildImpl &build, build_context &bc, u32 final_id,
+                        const vector<RoseEdge> &lit_edges) {
+    const auto &g = build.g;
+
+    DEBUG_PRINTF("final id %u, %zu lit edges\n", final_id, lit_edges.size());
+
+    // pred state id -> list of programs
+    map<u32, vector<vector<RoseInstruction>>> predProgramLists;
+
+    // Construct sparse iter sub-programs.
+    for (const auto &e : lit_edges) {
+        const auto &u = source(e, g);
+        if (build.isAnyStart(u)) {
+            continue; // Root roles are not handled with sparse iterator.
+        }
+        DEBUG_PRINTF("sparse iter edge (%zu,%zu)\n", g[u].idx,
+                     g[target(e, g)].idx);
+        assert(contains(bc.roleStateIndices, u));
+        u32 pred_state = bc.roleStateIndices.at(u);
+        auto program = makeProgram(build, bc, e);
+        predProgramLists[pred_state].push_back(program);
+    }
+
+    // Construct sub-program for handling root roles.
+    vector<vector<RoseInstruction>> root_programs;
+    for (const auto &e : lit_edges) {
+        const auto &u = source(e, g);
+        if (!build.isAnyStart(u)) {
+            continue;
+        }
+        DEBUG_PRINTF("root edge (%zu,%zu)\n", g[u].idx, g[target(e, g)].idx);
+        auto role_prog = makeProgram(build, bc, e);
+        if (role_prog.empty()) {
+            continue;
+        }
+        root_programs.push_back(role_prog);
+    }
+
+    // Literal may squash groups.
+    if (final_id != MO_INVALID_IDX) {
+        root_programs.push_back({});
+        makeGroupSquashInstruction(build, final_id, root_programs.back());
+    }
+
+    vector<RoseInstruction> root_program;
+    if (!root_programs.empty()) {
+        root_program = flattenProgram(root_programs);
+    }
+
+    auto pre_program = buildLitInitialProgram(build, bc, final_id, lit_edges);
+
+    // Put it all together.
+    return makeSparseIterProgram(bc, predProgramLists, root_program,
+                                 pre_program).first;
+}
+
+static
+u32 buildDelayRebuildProgram(RoseBuildImpl &build, build_context &bc,
+                             u32 final_id) {
+    const auto &lit_infos = getLiteralInfoByFinalId(build, final_id);
+    const auto &arb_lit_info = **lit_infos.begin();
+    if (arb_lit_info.delayed_ids.empty()) {
+        return 0; // No delayed IDs, no work to do.
+    }
+
+    vector<RoseInstruction> program;
+    makeCheckLitMaskInstruction(build, final_id, program);
+    makePushDelayedInstructions(build, final_id, program);
+    assert(!program.empty());
+    program = flattenProgram({program});
+    applyFinalSpecialisation(program);
+    return writeProgram(bc, program);
+}
+
+static
+map<u32, vector<RoseEdge>> findEdgesByLiteral(const RoseBuildImpl &build) {
+    // Use a set of edges while building the map to cull duplicates.
+    map<u32, flat_set<RoseEdge>> unique_lit_edge_map;
+
+    const auto &g = build.g;
+    for (const auto &e : edges_range(g)) {
+        const auto &v = target(e, g);
+        for (const auto &lit_id : g[v].literals) {
+            assert(lit_id < build.literal_info.size());
+            u32 final_id = build.literal_info.at(lit_id).final_id;
+            if (final_id == MO_INVALID_IDX) {
+                // Unused, special report IDs are handled elsewhere.
+                continue;
+            }
+            unique_lit_edge_map[final_id].insert(e);
+        }
+    }
+
+    // Build output map, sorting edges by (source, target) vertex index.
+    map<u32, vector<RoseEdge>> lit_edge_map;
+    for (const auto &m : unique_lit_edge_map) {
+        auto edge_list = vector<RoseEdge>(begin(m.second), end(m.second));
+        sort(begin(edge_list), end(edge_list),
+             [&g](const RoseEdge &a, const RoseEdge &b) {
+                 return tie(g[source(a, g)].idx, g[target(a, g)].idx) <
+                        tie(g[source(b, g)].idx, g[target(b, g)].idx);
+             });
+        lit_edge_map.emplace(m.first, edge_list);
+    }
+
+    return lit_edge_map;
+}
+
+/**
+ * \brief Build the interpreter programs for each literal.
+ *
+ * Returns the base of the literal program list and the base of the delay
+ * rebuild program list.
+ */
+static
+pair<u32, u32> buildLiteralPrograms(RoseBuildImpl &build, build_context &bc) {
+    const u32 num_literals = build.final_id_to_literal.size();
+    auto lit_edge_map = findEdgesByLiteral(build);
+
+    vector<u32> litPrograms(num_literals);
+    vector<u32> delayRebuildPrograms(num_literals);
+
+    for (u32 finalId = 0; finalId != num_literals; ++finalId) {
+        const auto &lit_edges = lit_edge_map[finalId];
+
+        litPrograms[finalId] =
+            buildLiteralProgram(build, bc, finalId, lit_edges);
+        delayRebuildPrograms[finalId] =
+            buildDelayRebuildProgram(build, bc, finalId);
+    }
+
+    u32 litProgramsOffset =
+        add_to_engine_blob(bc, begin(litPrograms), end(litPrograms));
+    u32 delayRebuildProgramsOffset = add_to_engine_blob(
+        bc, begin(delayRebuildPrograms), end(delayRebuildPrograms));
+
+    return {litProgramsOffset, delayRebuildProgramsOffset};
+}
+
+static
+u32 buildReportPrograms(RoseBuildImpl &build, build_context &bc) {
+    const auto &rm = build.rm;
+    const u32 numReports = verify_u32(rm.numReports());
+    vector<u32> programs(numReports);
+
+    vector<RoseInstruction> program;
+    for (ReportID id = 0; id < numReports; id++) {
+        program.clear();
+        const bool has_som = false;
+        makeCatchupMpv(build, bc, id, program);
+        makeReport(build, id, has_som, program);
+        program = flattenProgram({program});
+        applyFinalSpecialisation(program);
+        programs[id] = writeProgram(bc, program);
+        build.rm.setProgramOffset(id, programs[id]);
+        DEBUG_PRINTF("program for report %u @ %u (%zu instructions)\n", id,
+                     programs.back(), program.size());
+    }
+
+    return add_to_engine_blob(bc, begin(programs), end(programs));
+}
+
+static
+vector<RoseInstruction> makeEodAnchorProgram(RoseBuildImpl &build,
+                                             build_context &bc,
+                                             const RoseEdge &e) {
+    const RoseGraph &g = build.g;
+    const RoseVertex v = target(e, g);
+
+    vector<RoseInstruction> program;
+
+    if (g[e].history == ROSE_ROLE_HISTORY_ANCH) {
+        makeRoleCheckBounds(build, v, e, program);
+    }
+
+    if (hasGreaterInDegree(1, v, g)) {
+        // Only necessary when there is more than one pred.
+        makeRoleCheckNotHandled(bc, v, program);
+    }
+
+    const auto &reports = g[v].reports;
+    makeCatchup(build, bc, reports, program);
+
+    const bool has_som = false;
+    for (const auto &id : reports) {
+        makeReport(build, id, has_som, program);
+    }
+
+    return program;
+}
+
+/**
+ * Returns the pair (program offset, sparse iter offset).
+ */
+static
+pair<u32, u32> buildEodAnchorProgram(RoseBuildImpl &build, build_context &bc) {
     const RoseGraph &g = build.g;
 
-    u32 max_report = 0;
+    // pred state id -> list of programs
+    map<u32, vector<vector<RoseInstruction>>> predProgramLists;
 
-    for (RoseVertex v : vertices_range(g)) {
-        if (!build.isAnchored(v)) {
+    for (auto v : vertices_range(g)) {
+        if (!g[v].eod_accept) {
             continue;
         }
 
-        for (ReportID r : g[v].reports) {
-            art.push_back(r);
-            max_report = max(max_report, r);
+        DEBUG_PRINTF("vertex %zu (with %zu preds) fires on EOD\n", g[v].idx,
+                     in_degree(v, g));
+
+        for (const auto &e : in_edges_range(v, g)) {
+            RoseVertex u = source(e, g);
+
+            assert(contains(bc.roleStateIndices, u));
+            u32 predStateIdx = bc.roleStateIndices.at(u);
+
+            auto program = makeEodAnchorProgram(build, bc, e);
+            predProgramLists[predStateIdx].push_back(program);
         }
     }
 
-    assert(max_report < MO_INVALID_IDX);
-
-    arit.resize(max_report + 1, MO_INVALID_IDX);
-    for (u32 i = 0; i < art.size(); i++) {
-        DEBUG_PRINTF("art[%u] = %u\n", i, art[i]);
-        arit[art[i]] = i;
-        DEBUG_PRINTF("arit[%u] = %u\n", art[i], arit[art[i]]);
+    if (predProgramLists.empty()) {
+        DEBUG_PRINTF("no eod anchored roles\n");
+        return {0, 0};
     }
+
+    vector<RoseInstruction> program;
+
+    // Note: we force the use of a sparse iterator for the EOD program so we
+    // can easily guard EOD execution at runtime.
+    u32 iter_offset = addPredBlocks(bc, predProgramLists, program, true);
+
+    assert(program.size() > 1);
+    applyFinalSpecialisation(program);
+    return {writeProgram(bc, program), iter_offset};
+}
+
+static
+u32 writeEodProgram(RoseBuildImpl &build, build_context &bc) {
+    if (build.eod_event_literal_id == MO_INVALID_IDX) {
+        return 0;
+    }
+
+    const RoseGraph &g = build.g;
+    const auto &lit_info = build.literal_info.at(build.eod_event_literal_id);
+    assert(lit_info.delayed_ids.empty());
+    assert(!lit_info.squash_group);
+    assert(!lit_info.requires_benefits);
+
+    // Collect all edges leading into EOD event literal vertices.
+    vector<RoseEdge> edge_list;
+    for (const auto &v : lit_info.vertices) {
+        for (const auto &e : in_edges_range(v, g)) {
+            edge_list.push_back(e);
+        }
+    }
+
+    // Sort edge list for determinism, prettiness.
+    sort(begin(edge_list), end(edge_list),
+         [&g](const RoseEdge &a, const RoseEdge &b) {
+             return tie(g[source(a, g)].idx, g[target(a, g)].idx) <
+                    tie(g[source(b, g)].idx, g[target(b, g)].idx);
+         });
+
+    return buildLiteralProgram(build, bc, MO_INVALID_IDX, edge_list);
 }
 
 static
@@ -3836,51 +3963,45 @@ void fillMatcherDistances(const RoseBuildImpl &build, RoseEngine *engine) {
     if (!engine->anchoredDistance) {
         return;
     }
-
-    /* could be improved, if we have any side squash stuff and an anchored table
-     * set the min float distance to 0 */
-    if (!build.side_squash_roles.empty()) {
-        engine->floatingMinDistance = 0;
-    }
 }
 
 aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
     DerivedBoundaryReports dboundary(boundary);
 
-    // Build literal matchers
-    size_t asize = 0, fsize = 0, ssize = 0, esize = 0, sbsize = 0;
-
-    size_t floatingStreamStateRequired = 0;
     size_t historyRequired = calcHistoryRequired(); // Updated by HWLM.
 
-    aligned_unique_ptr<void> atable =
-        buildAnchoredAutomataMatcher(*this, &asize);
-    aligned_unique_ptr<HWLM> ftable = buildFloatingMatcher(
-        *this, &fsize, &historyRequired, &floatingStreamStateRequired);
-    aligned_unique_ptr<sidecar> stable = buildSideMatcher(*this, &ssize);
-    aligned_unique_ptr<HWLM> etable = buildEodAnchoredMatcher(*this, &esize);
-    aligned_unique_ptr<HWLM> sbtable = buildSmallBlockMatcher(*this, &sbsize);
+    auto anchored_dfas = buildAnchoredDfas(*this);
 
     build_context bc;
-    bc.depths = findDepths(*this);
+    bc.floatingMinLiteralMatchOffset =
+        findMinFloatingLiteralMatch(*this, anchored_dfas);
+    bc.needs_catchup = needsCatchup(*this);
+    recordResources(bc.resources, *this);
+    if (!anchored_dfas.empty()) {
+        bc.resources.has_anchored = true;
+    }
+    bc.needs_mpv_catchup = needsMpvCatchup(*this);
+
+    auto boundary_out = makeBoundaryPrograms(*this, bc, boundary, dboundary);
+
+    u32 reportProgramOffset = buildReportPrograms(*this, bc);
 
     // Build NFAs
-    vector<aligned_unique_ptr<NFA>> built_nfas;
-    map<suffix_id, u32> suffixes;
     set<u32> no_retrigger_queues;
     bool mpv_as_outfix;
-    prepMpv(*this, &built_nfas, &historyRequired, &mpv_as_outfix);
+    prepMpv(*this, bc, &historyRequired, &mpv_as_outfix);
     u32 outfixBeginQueue = qif.allocated_count();
-    if (!prepOutfixes(*this, &built_nfas, &historyRequired)) {
+    if (!prepOutfixes(*this, bc, &historyRequired)) {
         return nullptr;
     }
     u32 outfixEndQueue = qif.allocated_count();
     u32 leftfixBeginQueue = outfixEndQueue;
 
-    if (!buildNfas(*this, qif, &built_nfas, &suffixes, &bc.leftfix_info,
-                   &no_retrigger_queues, &leftfixBeginQueue)) {
+    if (!buildNfas(*this, bc, qif, &no_retrigger_queues,
+                   &leftfixBeginQueue)) {
         return nullptr;
     }
+    u32 eodNfaIterOffset = buildEodNfaIterator(bc, leftfixBeginQueue);
     buildCountingMiracles(*this, bc);
 
     u32 queue_count = qif.allocated_count(); /* excludes anchored matcher q;
@@ -3889,23 +4010,10 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
         throw ResourceLimitError();
     }
 
-    u32 lit_benefits_size =
-        verify_u32(sizeof(lit_benefits) * nonbenefits_base_id);
-    assert(ISALIGNED_16(lit_benefits_size));
-    u32 nfas_size = calcNfaSize(built_nfas);
-
-    // Build our other tables
-    DEBUG_PRINTF("nfas_size %u\n", nfas_size);
-
     vector<u32> suffixEkeyLists;
-    buildSuffixEkeyLists(*this, bc, qif, suffixes, &suffixEkeyLists);
+    buildSuffixEkeyLists(*this, bc, qif, &suffixEkeyLists);
 
-    buildInitialRoleTable(*this, bc);
-
-    DEBUG_PRINTF("roletable %zu\n", bc.roleTable.size());
-
-    vector<RosePred> predTable;
-    buildPredTable(*this, bc, predTable);
+    assignStateIndices(*this, bc);
 
     u32 laggedRoseCount = 0;
     vector<LeftNfaInfo> leftInfoTable;
@@ -3913,20 +4021,15 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
                        queue_count - leftfixBeginQueue, leftInfoTable,
                        &laggedRoseCount, &historyRequired);
 
-    buildRoseTriggerLists(*this, bc);
-
-    vector<RoseLiteral> literalTable;
-    buildLiteralTable(*this, bc, literalTable);
-    buildSparseIter(bc, literalTable, predTable);
+    u32 litProgramOffset;
+    u32 litDelayRebuildProgramOffset;
+    tie(litProgramOffset, litDelayRebuildProgramOffset) =
+        buildLiteralPrograms(*this, bc);
 
+    u32 eodProgramOffset = writeEodProgram(*this, bc);
+    u32 eodIterProgramOffset;
     u32 eodIterOffset;
-    u32 eodIterMapOffset;
-
-    tie(eodIterMapOffset, eodIterOffset) = buildEodAnchorRoles(*this, bc,
-                                                               predTable);
-
-    vector<RoseSide> sideTable;
-    buildSideTable(*this, bc, sideTable);
+    tie(eodIterProgramOffset, eodIterOffset) = buildEodAnchorProgram(*this, bc);
 
     vector<mmbit_sparse_iter> activeLeftIter;
     buildActiveLeftIter(leftInfoTable, activeLeftIter);
@@ -3934,16 +4037,10 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
     u32 lastByteOffset = buildLastByteIter(g, bc);
 
     // Enforce role table resource limit.
-    if (bc.roleTable.size() > cc.grey.limitRoseRoleCount) {
+    if (num_vertices(g) > cc.grey.limitRoseRoleCount) {
         throw ResourceLimitError();
     }
 
-    u32 amatcherOffset = 0;
-    u32 fmatcherOffset = 0;
-    u32 smatcherOffset = 0;
-    u32 ematcherOffset = 0;
-    u32 sbmatcherOffset = 0;
-
     u32 currOffset;  /* relative to base of RoseEngine */
     if (!bc.engine_blob.empty()) {
         currOffset = bc.engine_blob_base + byte_length(bc.engine_blob);
@@ -3951,64 +4048,54 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
         currOffset = sizeof(RoseEngine);
     }
 
+    UNUSED const size_t engineBlobSize =
+        byte_length(bc.engine_blob); // test later
+
     currOffset = ROUNDUP_CL(currOffset);
     DEBUG_PRINTF("currOffset %u\n", currOffset);
 
-    /* leave space for the nfas */
-    u32 base_nfa_offset = currOffset;
-    currOffset += nfas_size;
-
-    /* leave space for the benefits listing */
-    u32 base_lits_benefits_offset = currOffset;
-    currOffset += lit_benefits_size;
-
+    // Build anchored matcher.
+    size_t asize = 0;
+    u32 amatcherOffset = 0;
+    auto atable = buildAnchoredMatcher(*this, anchored_dfas, &asize);
     if (atable) {
         currOffset = ROUNDUP_CL(currOffset);
         amatcherOffset = currOffset;
-        currOffset += (u32)asize;
+        currOffset += verify_u32(asize);
     }
 
+    // Build floating HWLM matcher.
+    size_t fsize = 0;
+    size_t floatingStreamStateRequired = 0;
+    auto ftable = buildFloatingMatcher(*this, &fsize, &historyRequired,
+                                       &floatingStreamStateRequired);
+    u32 fmatcherOffset = 0;
     if (ftable) {
         currOffset = ROUNDUP_CL(currOffset);
         fmatcherOffset = currOffset;
-        currOffset += (u32)fsize;
-    }
-
-    if (stable) {
-        currOffset = ROUNDUP_CL(currOffset);
-        smatcherOffset = currOffset;
-        currOffset += (u32)ssize;
+        currOffset += verify_u32(fsize);
     }
 
+    // Build EOD-anchored HWLM matcher.
+    size_t esize = 0;
+    auto etable = buildEodAnchoredMatcher(*this, &esize);
+    u32 ematcherOffset = 0;
     if (etable) {
         currOffset = ROUNDUP_CL(currOffset);
         ematcherOffset = currOffset;
-        currOffset += (u32)esize;
+        currOffset += verify_u32(esize);
     }
 
+    // Build small-block HWLM matcher.
+    size_t sbsize = 0;
+    auto sbtable = buildSmallBlockMatcher(*this, &sbsize);
+    u32 sbmatcherOffset = 0;
     if (sbtable) {
         currOffset = ROUNDUP_CL(currOffset);
         sbmatcherOffset = currOffset;
-        currOffset += (u32)sbsize;
+        currOffset += verify_u32(sbsize);
     }
 
-    const vector<Report> &int_reports = rm.reports();
-
-    currOffset = ROUNDUP_CL(currOffset);
-    u32 intReportOffset = currOffset;
-    currOffset += sizeof(internal_report) * int_reports.size();
-
-    u32 literalOffset = ROUNDUP_N(currOffset, alignof(RoseLiteral));
-    u32 literalLen = sizeof(RoseLiteral) * literalTable.size();
-    currOffset = literalOffset + literalLen;
-
-    u32 sideOffset = ROUNDUP_N(currOffset, alignof(RoseSide));
-    currOffset = sideOffset + byte_length(sideTable);
-
-    u32 roleOffset = ROUNDUP_N(currOffset, alignof(RoseRole));
-    u32 roleLen = sizeof(RoseRole) * bc.roleTable.size();
-    currOffset = roleOffset + roleLen;
-
     u32 leftOffset = ROUNDUP_N(currOffset, alignof(LeftNfaInfo));
     u32 roseLen = sizeof(LeftNfaInfo) * leftInfoTable.size();
     currOffset = leftOffset + roseLen;
@@ -4021,44 +4108,10 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
     u32 lookaroundTableLen = sizeof(s8) * bc.lookaround.size();
     currOffset = lookaroundTableOffset + lookaroundTableLen;
 
-    u32 predOffset = ROUNDUP_N(currOffset, alignof(RosePred));
-    u32 predLen = sizeof(RosePred) * predTable.size();
-    currOffset = predOffset + predLen;
-
     u32 nfaInfoOffset = ROUNDUP_N(currOffset, sizeof(u32));
     u32 nfaInfoLen = sizeof(NfaInfo) * queue_count;
     currOffset = nfaInfoOffset + nfaInfoLen;
 
-    vector<u32> rootRoleTable;
-    buildRootRoleTable(*this, roleOffset, literalTable, &rootRoleTable);
-
-    u32 rootRoleOffset = ROUNDUP_N(currOffset, sizeof(u32));
-    u32 rootRoleLen = sizeof(u32) * rootRoleTable.size();
-    currOffset = rootRoleOffset + rootRoleLen;
-
-    vector<ReportID> art; // Reports raised by anchored roles
-    vector<u32> arit; // inverse reportID -> position in art
-    calcAnchoredMatches(*this, art, arit);
-
-    currOffset = ROUNDUP_N(currOffset, sizeof(ReportID));
-    u32 anchoredReportMapOffset = currOffset;
-    currOffset += art.size() * sizeof(ReportID);
-
-    currOffset = ROUNDUP_N(currOffset, sizeof(u32));
-    u32 anchoredReportInverseMapOffset = currOffset;
-    currOffset += arit.size() * sizeof(u32);
-
-    /* sidecar may contain sse in silly cases */
-    currOffset = ROUNDUP_N(currOffset, 16);
-    u32 sideSuccListOffset = currOffset;
-    map<set<u32>, set<RoseVertex> > sidecar_succ_map;
-    markSideEnablers(*this, &sidecar_succ_map);
-    currOffset += sizeSideSuccMasks(stable.get(), sidecar_succ_map);
-
-    currOffset = ROUNDUP_N(currOffset, alignof(ReportID));
-    u32 multidirectOffset = currOffset;
-    currOffset += mdr_reports.size() * sizeof(ReportID);
-
     currOffset = ROUNDUP_N(currOffset, alignof(mmbit_sparse_iter));
     u32 activeLeftIterOffset = currOffset;
     currOffset += activeLeftIter.size() * sizeof(mmbit_sparse_iter);
@@ -4067,16 +4120,13 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
     u32 activeLeftCount = leftInfoTable.size();
     u32 rosePrefixCount = countRosePrefixes(leftInfoTable);
 
-    RoseBoundaryReports boundary_out;
-    reserveBoundaryReports(boundary, dboundary, &boundary_out, &currOffset);
-
     u32 rev_nfa_table_offset;
     vector<u32> rev_nfa_offsets;
     prepSomRevNfas(ssm, &rev_nfa_table_offset, &rev_nfa_offsets, &currOffset);
 
     // Build engine header and copy tables into place.
 
-    u32 anchorStateSize = anchoredStateSize(atable.get());
+    u32 anchorStateSize = atable ? anchoredStateSize(*atable) : 0;
 
     DEBUG_PRINTF("rose history required %zu\n", historyRequired);
     assert(!cc.streaming || historyRequired <= cc.grey.maxHistoryAvailable);
@@ -4089,13 +4139,13 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
 
     RoseStateOffsets stateOffsets;
     memset(&stateOffsets, 0, sizeof(stateOffsets));
-    fillStateOffsets(*this, stable.get(), bc.numStates, anchorStateSize,
+    fillStateOffsets(*this, bc.numStates, anchorStateSize,
                      activeArrayCount, activeLeftCount, laggedRoseCount,
                      floatingStreamStateRequired, historyRequired,
                      &stateOffsets);
 
     scatter_plan_raw state_scatter;
-    buildStateScatterPlan(sizeof(RoseRuntimeState), bc.numStates,
+    buildStateScatterPlan(sizeof(u8), bc.numStates,
                           activeLeftCount, rosePrefixCount, stateOffsets,
                           cc.streaming, activeArrayCount, outfixBeginQueue,
                           outfixEndQueue, &state_scatter);
@@ -4116,28 +4166,19 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
     assert(ISALIGNED_CL(ptr));
 
     if (atable) {
-        assert(amatcherOffset >= base_nfa_offset);
         assert(amatcherOffset);
         memcpy(ptr + amatcherOffset, atable.get(), asize);
     }
     if (ftable) {
         assert(fmatcherOffset);
-        assert(fmatcherOffset >= base_nfa_offset);
         memcpy(ptr + fmatcherOffset, ftable.get(), fsize);
     }
-    if (stable) {
-        assert(smatcherOffset);
-        assert(smatcherOffset >= base_nfa_offset);
-        memcpy(ptr + smatcherOffset, stable.get(), ssize);
-    }
     if (etable) {
         assert(ematcherOffset);
-        assert(ematcherOffset >= base_nfa_offset);
         memcpy(ptr + ematcherOffset, etable.get(), esize);
     }
     if (sbtable) {
         assert(sbmatcherOffset);
-        assert(sbmatcherOffset >= base_nfa_offset);
         memcpy(ptr + sbmatcherOffset, sbtable.get(), sbsize);
     }
 
@@ -4153,28 +4194,25 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
     engine->somHorizon = ssm.somPrecision();
     engine->somLocationCount = ssm.numSomSlots();
 
-    engine->simpleCallback = !rm.numEkeys() && hasSimpleReports(rm.reports());
+    engine->needsCatchup = bc.needs_catchup ? 1 : 0;
 
-    fillInReportInfo(engine.get(), intReportOffset, rm, int_reports);
-
-    engine->literalOffset = literalOffset;
-    engine->literalCount = verify_u32(literalTable.size());
-    engine->runtimeImpl = pickRuntimeImpl(*this, outfixEndQueue);
+    engine->literalCount = verify_u32(final_id_to_literal.size());
+    engine->litProgramOffset = litProgramOffset;
+    engine->litDelayRebuildProgramOffset = litDelayRebuildProgramOffset;
+    engine->reportProgramOffset = reportProgramOffset;
+    engine->reportProgramCount = verify_u32(rm.reports().size());
+    engine->runtimeImpl = pickRuntimeImpl(*this, bc, outfixEndQueue);
     engine->mpvTriggeredByLeaf = anyEndfixMpvTriggers(*this);
 
-    engine->sideOffset = sideOffset;
-    engine->sideCount = verify_u32(sideTable.size());
-
     engine->activeArrayCount = activeArrayCount;
     engine->activeLeftCount = activeLeftCount;
     engine->queueCount = queue_count;
+    engine->handledKeyCount = bc.handledKeys.size();
 
     engine->group_weak_end = group_weak_end;
 
     engine->rolesWithStateCount = bc.numStates;
 
-    engine->roleOffset = roleOffset;
-    engine->roleCount = verify_u32(bc.roleTable.size());
     engine->leftOffset = leftOffset;
     engine->roseCount = verify_u32(leftInfoTable.size());
     engine->lookaroundTableOffset = lookaroundTableOffset;
@@ -4183,34 +4221,23 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
     engine->outfixEndQueue = outfixEndQueue;
     engine->leftfixBeginQueue = leftfixBeginQueue;
     engine->initMpvNfa = mpv_as_outfix ? 0 : MO_INVALID_IDX;
-    engine->predOffset = predOffset;
-    engine->predCount = verify_u32(predTable.size());
     engine->stateSize = mmbit_size(bc.numStates);
     engine->anchorStateSize = anchorStateSize;
     engine->nfaInfoOffset = nfaInfoOffset;
-    engine->anchoredReportMapOffset = anchoredReportMapOffset;
-    engine->anchoredReportInverseMapOffset
-        = anchoredReportInverseMapOffset;
-    engine->multidirectOffset = multidirectOffset;
-    engine->rootRoleCount = verify_u32(rootRoleTable.size());
-    engine->rootRoleOffset = rootRoleOffset;
 
+    engine->eodProgramOffset = eodProgramOffset;
+    engine->eodIterProgramOffset = eodIterProgramOffset;
     engine->eodIterOffset = eodIterOffset;
-    engine->eodIterMapOffset = eodIterMapOffset;
+    engine->eodNfaIterOffset = eodNfaIterOffset;
 
     engine->lastByteHistoryIterOffset = lastByteOffset;
 
-    u32 delay_count = verify_u32(literalTable.size() - delay_base_id);
+    u32 delay_count = verify_u32(final_id_to_literal.size() - delay_base_id);
     engine->delay_count = delay_count;
-    engine->delay_slot_size = mmbit_size(delay_count);
     engine->delay_base_id = delay_base_id;
     engine->anchored_base_id = anchored_base_id;
     engine->anchored_count = delay_base_id - anchored_base_id;
-    engine->nonbenefits_base_id = nonbenefits_base_id;
-    engine->literalBenefitsOffsets = base_lits_benefits_offset;
 
-    populateSideSuccLists(*this, bc, stable.get(), engine.get(),
-                          sideSuccListOffset, sidecar_succ_map);
     engine->rosePrefixCount = rosePrefixCount;
 
     engine->activeLeftIterOffset
@@ -4234,7 +4261,6 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
     engine->ematcherOffset = ematcherOffset;
     engine->sbmatcherOffset = sbmatcherOffset;
     engine->fmatcherOffset = fmatcherOffset;
-    engine->smatcherOffset = smatcherOffset;
     engine->amatcherMinWidth = findMinWidth(*this, ROSE_ANCHORED);
     engine->fmatcherMinWidth = findMinWidth(*this, ROSE_FLOATING);
     engine->eodmatcherMinWidth = findMinWidth(*this, ROSE_EOD_ANCHORED);
@@ -4243,87 +4269,51 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
     engine->size = currOffset;
     engine->minWidth = hasBoundaryReports(boundary) ? 0 : minWidth;
     engine->minWidthExcludingBoundaries = minWidth;
-    engine->maxSafeAnchoredDROffset = findMinWidth(*this, ROSE_FLOATING);
-    engine->floatingMinLiteralMatchOffset = findMinFloatingLiteralMatch(*this);
+    engine->floatingMinLiteralMatchOffset = bc.floatingMinLiteralMatchOffset;
 
     engine->maxBiAnchoredWidth = findMaxBAWidth(*this);
     engine->noFloatingRoots = hasNoFloatingRoots();
-    engine->hasFloatingDirectReports = floating_direct_report;
-    engine->requiresEodCheck = hasEodAnchors(*this, built_nfas,
-                                             outfixEndQueue);
-    engine->requiresEodSideCatchup = hasEodSideLink();
+    engine->requiresEodCheck = hasEodAnchors(*this, bc, outfixEndQueue);
     engine->hasOutfixesInSmallBlock = hasNonSmallBlockOutfix(outfixes);
     engine->canExhaust = rm.patternSetCanExhaust();
     engine->hasSom = hasSom;
-    engine->anchoredMatches = verify_u32(art.size());
 
     /* populate anchoredDistance, floatingDistance, floatingMinDistance, etc */
     fillMatcherDistances(*this, engine.get());
 
     engine->initialGroups = getInitialGroups();
-    engine->totalNumLiterals = verify_u32(literalTable.size());
+    engine->totalNumLiterals = verify_u32(literal_info.size());
     engine->asize = verify_u32(asize);
     engine->ematcherRegionSize = ematcher_region_size;
     engine->floatingStreamState = verify_u32(floatingStreamStateRequired);
-    populateBoundaryReports(engine.get(), boundary, dboundary, boundary_out);
+
+    engine->boundary.reportEodOffset = boundary_out.reportEodOffset;
+    engine->boundary.reportZeroOffset = boundary_out.reportZeroOffset;
+    engine->boundary.reportZeroEodOffset = boundary_out.reportZeroEodOffset;
 
     write_out(&engine->state_init, (char *)engine.get(), state_scatter,
               state_scatter_aux_offset);
 
-    if (eod_event_literal_id != MO_INVALID_IDX) {
-        engine->hasEodEventLiteral = 1;
-        DEBUG_PRINTF("eod literal id=%u, final_id=%u\n", eod_event_literal_id,
-                     literal_info.at(eod_event_literal_id).final_id);
-        engine->eodLiteralId = literal_info.at(eod_event_literal_id).final_id;
-    }
-
-    if (anchoredIsMulti(*engine)) {
-        DEBUG_PRINTF("multiple anchored dfas\n");
-        engine->maxSafeAnchoredDROffset = 1;
-        engine->floatingMinLiteralMatchOffset = 1; /* regard matches from other
-                                                      anchored tables as
-                                                      floating as unordered. */
-    } else {
-        /* overly conservative, really need the min offset of non dr anchored
-           matches */
-        engine->maxSafeAnchoredDROffset = MIN(engine->maxSafeAnchoredDROffset,
-                                        engine->floatingMinLiteralMatchOffset);
-    }
-
     NfaInfo *nfa_infos = (NfaInfo *)(ptr + nfaInfoOffset);
-    populateNfaInfoBasics(nfa_infos, outfixes, rm, suffixes, suffixEkeyLists);
-    updateNfaState(built_nfas, bc.leftfix_info, &engine->stateOffsets, nfa_infos,
+    populateNfaInfoBasics(*this, bc, outfixes, suffixEkeyLists,
+                          no_retrigger_queues, nfa_infos);
+    updateNfaState(bc, &engine->stateOffsets, nfa_infos,
                    &engine->scratchStateSize, &engine->nfaStateSize,
                    &engine->tStateSize);
 
-    // Copy in the NFAs and update roles
-    engine->nfaRegionBegin = base_nfa_offset;
-    engine->nfaRegionEnd = copyInNFAs(*this, &bc.roleTable, built_nfas,
-                                      no_retrigger_queues, nfa_infos,
-                                      base_nfa_offset, suffixes, ptr);
-    // We're done with the NFAs.
-    built_nfas.clear();
-
-    /* do after update mask */
-    buildLitBenefits(*this, engine.get(), base_lits_benefits_offset);
-
     // Copy in other tables
     copy_bytes(ptr + bc.engine_blob_base, bc.engine_blob);
-    copy_bytes(ptr + engine->literalOffset, literalTable);
-    copy_bytes(ptr + engine->roleOffset, bc.roleTable);
     copy_bytes(ptr + engine->leftOffset, leftInfoTable);
 
     fillLookaroundTables(ptr + lookaroundTableOffset,
                          ptr + lookaroundReachOffset, bc.lookaround);
 
     fillInSomRevNfas(engine.get(), ssm, rev_nfa_table_offset, rev_nfa_offsets);
-    copy_bytes(ptr + engine->predOffset, predTable);
-    copy_bytes(ptr + engine->rootRoleOffset, rootRoleTable);
-    copy_bytes(ptr + engine->anchoredReportMapOffset, art);
-    copy_bytes(ptr + engine->anchoredReportInverseMapOffset, arit);
-    copy_bytes(ptr + engine->multidirectOffset, mdr_reports);
     copy_bytes(ptr + engine->activeLeftIterOffset, activeLeftIter);
-    copy_bytes(ptr + engine->sideOffset, sideTable);
+
+    // Safety check: we shouldn't have written anything to the engine blob
+    // after we copied it into the engine bytecode.
+    assert(byte_length(bc.engine_blob) == engineBlobSize);
 
     DEBUG_PRINTF("rose done %p\n", engine.get());
     return engine;
diff --git a/src/rose/rose_build_castle.cpp b/src/rose/rose_build_castle.cpp
new file mode 100644
index 00000000..c65e840d
--- /dev/null
+++ b/src/rose/rose_build_castle.cpp
@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "rose_build_castle.h"
+
+#include "rose_build_impl.h"
+#include "ue2common.h"
+#include "nfa/castlecompile.h"
+#include "nfagraph/ng_holder.h"
+#include "nfagraph/ng_puff.h"
+#include "util/charreach.h"
+#include "util/compile_context.h"
+#include "util/container.h"
+#include "util/dump_charclass.h"
+#include "util/graph_range.h"
+#include "util/ue2_containers.h"
+#include "util/ue2string.h"
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <boost/range/adaptor/map.hpp>
+
+using namespace std;
+using boost::adaptors::map_values;
+
+namespace ue2 {
+
+static
+void makeCastle(LeftEngInfo &left,
+               unordered_map<const NGHolder *, shared_ptr<CastleProto>> &cache) {
+    if (left.dfa || left.haig || left.castle) {
+        return;
+    }
+    if (!left.graph) {
+        return;
+    }
+
+    const NGHolder &h = *left.graph;
+    DEBUG_PRINTF("prefix %p\n", &h);
+
+    if (contains(cache, &h)) {
+        DEBUG_PRINTF("using cached CastleProto\n");
+        left.castle = cache[&h];
+        left.graph.reset();
+        return;
+    }
+
+    PureRepeat pr;
+    if (isPureRepeat(h, pr) && pr.reports.size() == 1) {
+        DEBUG_PRINTF("vertex preceded by infix repeat %s\n",
+                     pr.bounds.str().c_str());
+        left.castle = make_shared<CastleProto>(h.kind, pr);
+        cache[&h] = left.castle;
+        left.graph.reset();
+    }
+}
+
+static
+void makeCastleSuffix(RoseBuildImpl &tbi, RoseVertex v,
+        ue2::unordered_map<const NGHolder *, shared_ptr<CastleProto> > &cache) {
+    RoseSuffixInfo &suffix = tbi.g[v].suffix;
+    if (!suffix.graph) {
+        return;
+    }
+    const NGHolder &h = *suffix.graph;
+    DEBUG_PRINTF("suffix %p\n", &h);
+
+    if (contains(cache, &h)) {
+        DEBUG_PRINTF("using cached CastleProto\n");
+        suffix.castle = cache[&h];
+        suffix.graph.reset();
+        return;
+    }
+
+    // The MPV will probably do a better job on the cases it's designed
+    // for.
+    const bool fixed_depth = tbi.g[v].min_offset == tbi.g[v].max_offset;
+    if (isPuffable(h, fixed_depth, tbi.rm, tbi.cc.grey)) {
+        DEBUG_PRINTF("leaving suffix for puff\n");
+        return;
+    }
+
+    PureRepeat pr;
+    if (isPureRepeat(h, pr) && pr.reports.size() == 1) {
+        DEBUG_PRINTF("suffix repeat %s\n", pr.bounds.str().c_str());
+
+        // Right now, the Castle uses much more stream state to represent a
+        // {m,1} repeat than just leaving it to an NFA.
+        if (pr.bounds.max <= depth(1)) {
+            DEBUG_PRINTF("leaving for other engines\n");
+            return;
+        }
+
+        suffix.castle = make_shared<CastleProto>(h.kind, pr);
+        cache[&h] = suffix.castle;
+        suffix.graph.reset();
+    }
+}
+
+static
+vector<rose_literal_id> literals_for_vertex(const RoseBuildImpl &tbi,
+                                            RoseVertex v) {
+    vector<rose_literal_id> rv;
+
+    for (const u32 id : tbi.g[v].literals) {
+        rv.push_back(tbi.literals.right.at(id));
+    }
+
+    return rv;
+}
+
+static
+void renovateCastle(RoseBuildImpl &tbi, CastleProto *castle,
+              const vector<RoseVertex> &verts) {
+    DEBUG_PRINTF("looking to renovate\n");
+
+    if (castle->repeats.size() != 1) {
+        assert(0);  /* should not have merged castles yet */
+        return;
+    }
+
+    PureRepeat &pr = castle->repeats.begin()->second;
+    if (pr.bounds.max.is_finite()) {
+        /* repeat cannot be turned into pseudo .* */
+        return;
+    }
+
+    RoseGraph &g = tbi.g;
+    const CharReach &cr = castle->reach();
+
+    DEBUG_PRINTF("cr || %zu\n", cr.count());
+
+    u32 allowed_to_remove = ~0;
+    size_t min_succ_lit_len = 0;
+
+    for (RoseVertex v : verts) {
+        assert(g[v].left.castle.get() == castle);
+        DEBUG_PRINTF("%zu checks at lag %u\n", g[v].idx, g[v].left.lag);
+        vector<rose_literal_id> lits = literals_for_vertex(tbi, v);
+        for (const auto &e : lits) {
+            DEBUG_PRINTF("%s +%u\n", dumpString(e.s).c_str(), e.delay);
+            if (e.delay) {
+                return; /* bail - TODO: be less lazy */
+            }
+
+            vector<CharReach> rem_local_cr;
+            u32 ok_count = 0;
+            for (auto it = e.s.end() - g[v].left.lag; it != e.s.end(); ++it) {
+                if (!isSubsetOf(*it, cr)) {
+                    break;
+                }
+
+                ok_count++;
+            }
+            LIMIT_TO_AT_MOST(&allowed_to_remove, ok_count);
+            ENSURE_AT_LEAST(&min_succ_lit_len, e.elength());
+        }
+    }
+
+    DEBUG_PRINTF("possible to decrease lag by %u\n", allowed_to_remove);
+
+
+    for (RoseVertex v : verts) {
+        assert(g[v].left.lag >= allowed_to_remove);
+        g[v].left.lag -= allowed_to_remove;
+    }
+
+    assert(castle->repeats.size() == 1); /* should not have merged castles yet */
+
+    pr.bounds.max += allowed_to_remove;
+
+    /* Although it is always safe to increase the min bound as well, we would
+     * rather not as a >0 min bound means that we have to store state as well.
+     *
+     * As it was legal to run with the original lag, we know that it is not
+     * possible to have an overlapping match which finishes within the trigger
+     * literal past the original lag point. However, if there is already a min
+     * bound constraint this would be broken if we did not also increase the
+     * min bound. */
+
+    if (pr.bounds.min > 0ULL || allowed_to_remove > min_succ_lit_len) {
+        pr.bounds.min += allowed_to_remove;
+    }
+}
+
+void makeCastles(RoseBuildImpl &tbi) {
+    if (!tbi.cc.grey.allowCastle && !tbi.cc.grey.allowLbr) {
+        return;
+    }
+
+    RoseGraph &g = tbi.g;
+
+    // Caches so that we can reuse analysis on graphs we've seen already.
+    unordered_map<const NGHolder *, shared_ptr<CastleProto> > left_cache;
+    unordered_map<const NGHolder *, shared_ptr<CastleProto> > suffix_cache;
+
+    unordered_map<CastleProto *, vector<RoseVertex>> rev;
+
+    for (RoseVertex v : vertices_range(g)) {
+        if (g[v].left && !tbi.isRootSuccessor(v)) {
+            makeCastle(g[v].left, left_cache);
+            if (g[v].left.castle) {
+                rev[g[v].left.castle.get()].push_back(v);
+            }
+        }
+
+        if (g[v].suffix) {
+            makeCastleSuffix(tbi, v, suffix_cache);
+        }
+    }
+
+    for (const auto &e : rev) {
+        renovateCastle(tbi, e.first, e.second);
+    }
+}
+
+bool unmakeCastles(RoseBuildImpl &tbi) {
+    RoseGraph &g = tbi.g;
+
+    const size_t MAX_UNMAKE_VERTICES = 64;
+
+    map<left_id, vector<RoseVertex> > left_castles;
+    map<suffix_id, vector<RoseVertex> > suffix_castles;
+    bool changed = false;
+
+    for (auto v : vertices_range(g)) {
+        const LeftEngInfo &left = g[v].left;
+        if (left.castle && left.castle->repeats.size() > 1) {
+            left_castles[left].push_back(v);
+        }
+        const RoseSuffixInfo &suffix = g[v].suffix;
+        if (suffix.castle && suffix.castle->repeats.size() > 1) {
+            suffix_castles[suffix].push_back(v);
+        }
+    }
+
+    for (const auto &e : left_castles) {
+        assert(e.first.castle());
+        shared_ptr<NGHolder> h = makeHolder(*e.first.castle(), tbi.cc);
+        if (!h || num_vertices(*h) > MAX_UNMAKE_VERTICES) {
+            continue;
+        }
+        DEBUG_PRINTF("replace rose with holder (%zu vertices)\n",
+                     num_vertices(*h));
+        for (auto v : e.second) {
+            assert(g[v].left.castle.get() == e.first.castle());
+            g[v].left.graph = h;
+            g[v].left.castle.reset();
+            changed = true;
+        }
+    }
+
+    for (const auto &e : suffix_castles) {
+        assert(e.first.castle());
+        shared_ptr<NGHolder> h = makeHolder(*e.first.castle(), tbi.cc);
+        if (!h || num_vertices(*h) > MAX_UNMAKE_VERTICES) {
+            continue;
+        }
+        DEBUG_PRINTF("replace suffix with holder (%zu vertices)\n",
+                     num_vertices(*h));
+        for (auto v : e.second) {
+            assert(g[v].suffix.castle.get() == e.first.castle());
+            g[v].suffix.graph = h;
+            g[v].suffix.castle.reset();
+            changed = true;
+        }
+    }
+
+    return changed;
+}
+
+void remapCastleTops(RoseBuildImpl &tbi) {
+    ue2::unordered_map<CastleProto *, vector<RoseVertex> > rose_castles;
+    ue2::unordered_map<CastleProto *, vector<RoseVertex> > suffix_castles;
+
+    RoseGraph &g = tbi.g;
+    for (auto v : vertices_range(g)) {
+        if (g[v].left.castle) {
+            rose_castles[g[v].left.castle.get()].push_back(v);
+        }
+        if (g[v].suffix.castle) {
+            suffix_castles[g[v].suffix.castle.get()].push_back(v);
+        }
+    }
+
+    DEBUG_PRINTF("%zu rose castles, %zu suffix castles\n", rose_castles.size(),
+                  suffix_castles.size());
+
+    map<u32, u32> top_map;
+
+    // Remap Rose Castles.
+    for (const auto &rc : rose_castles) {
+        CastleProto *c = rc.first;
+        const vector<RoseVertex> &verts = rc.second;
+
+        DEBUG_PRINTF("rose castle %p (%zu repeats) has %zu verts\n", c,
+                      c->repeats.size(), verts.size());
+
+        top_map.clear();
+        remapCastleTops(*c, top_map);
+
+        // Update the tops on the edges leading into vertices in v.
+        for (auto v : verts) {
+            for (const auto &e : in_edges_range(v, g)) {
+                g[e].rose_top = top_map.at(g[e].rose_top);
+            }
+        }
+    }
+
+    // Remap Suffix Castles.
+    for (const auto &e : suffix_castles) {
+        CastleProto *c = e.first;
+        const vector<RoseVertex> &verts = e.second;
+
+        DEBUG_PRINTF("suffix castle %p (%zu repeats) has %zu verts\n", c,
+                      c->repeats.size(), verts.size());
+
+        top_map.clear();
+        remapCastleTops(*c, top_map);
+
+        // Update the tops on the suffixes.
+        for (auto v : verts) {
+            assert(g[v].suffix);
+            g[v].suffix.top = top_map.at(g[v].suffix.top);
+        }
+    }
+}
+
+bool triggerKillsRoseCastle(const RoseBuildImpl &tbi, const left_id &left,
+                            const set<ue2_literal> &all_lits,
+                            const RoseEdge &e) {
+    assert(left.castle());
+    const CastleProto &c = *left.castle();
+
+    const depth max_width = findMaxWidth(c);
+    DEBUG_PRINTF("castle max width is %s\n", max_width.str().c_str());
+
+    /* check each pred literal to see if they all kill previous castle
+     * state */
+    for (u32 lit_id : tbi.g[source(e, tbi.g)].literals) {
+        const rose_literal_id &pred_lit = tbi.literals.right.at(lit_id);
+        const ue2_literal s = findNonOverlappingTail(all_lits, pred_lit.s);
+        const CharReach &cr = c.reach();
+
+        DEBUG_PRINTF("s=%s, castle reach=%s\n", dumpString(s).c_str(),
+                      describeClass(cr).c_str());
+
+        for (const auto &s_cr : s) {
+            if (!overlaps(cr, s_cr)) {
+                DEBUG_PRINTF("reach %s kills castle\n",
+                             describeClass(s_cr).c_str());
+                goto next_pred;
+            }
+        }
+
+        if (max_width < depth(s.length())) {
+            DEBUG_PRINTF("literal width >= castle max width\n");
+            goto next_pred;
+        }
+
+        return false;
+
+    next_pred:;
+    }
+
+    return true;
+}
+
+} // namespace ue2
diff --git a/src/sidecar/sidecar_compile.h b/src/rose/rose_build_castle.h
similarity index 62%
rename from src/sidecar/sidecar_compile.h
rename to src/rose/rose_build_castle.h
index 2a8c2c32..4a2b6188 100644
--- a/src/sidecar/sidecar_compile.h
+++ b/src/rose/rose_build_castle.h
@@ -26,36 +26,44 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SIDECAR_COMPILE_H
-#define SIDECAR_COMPILE_H
+#ifndef ROSE_BUILD_CASTLE_H
+#define ROSE_BUILD_CASTLE_H
 
-#include "ue2common.h"
-#include "util/alloc.h"
+#include "rose_graph.h"
 
-#include <memory>
-#include <vector>
-
-struct sidecar;
-struct sidecar_enabled;
+#include <set>
 
 namespace ue2 {
 
-class CharReach;
+class RoseBuildImpl;
+struct left_id;
+struct ue2_literal;
 
-#define SIDECAR_NO_HINT (-1)
-
-/*
- * match ids are given by position in the report_map vector
+/**
+ * Runs over all rose infix/suffix engines and converts those that are pure
+ * repeats with one report into CastleProto engines.
  */
-aligned_unique_ptr<sidecar>
-sidecarCompile(const std::vector<CharReach> &classes,
-               int hint = SIDECAR_NO_HINT);
+void makeCastles(RoseBuildImpl &tbi);
 
-u32 sidecarSize(const sidecar *ns);
-u32 sidecarEnabledSize(const sidecar *n);
-void sidecarEnabledAdd(const sidecar *n, struct sidecar_enabled *enabled,
-                       u32 id);
+/**
+ * Identifies all the CastleProto prototypes that are small enough that they
+ * would be better implemented as NFAs, and converts them back to NGHolder
+ * prototypes.
+ *
+ * Returns true if any changes were made.
+ */
+bool unmakeCastles(RoseBuildImpl &tbi);
 
-} // namespace ue2
+/**
+ * Runs over all the Castle engine prototypes in the graph and ensures that
+ * they have tops in a contiguous range, ready for construction.
+ */
+void remapCastleTops(RoseBuildImpl &tbi);
+
+bool triggerKillsRoseCastle(const RoseBuildImpl &tbi, const left_id &left,
+                            const std::set<ue2_literal> &all_lits,
+                            const RoseEdge &e);
+
+}
 
 #endif
diff --git a/src/rose/rose_build_compile.cpp b/src/rose/rose_build_compile.cpp
index a2bd971e..12500599 100644
--- a/src/rose/rose_build_compile.cpp
+++ b/src/rose/rose_build_compile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -31,13 +31,13 @@
 #include "grey.h"
 #include "hs_internal.h"
 #include "rose_build_anchored.h"
+#include "rose_build_castle.h"
 #include "rose_build_convert.h"
 #include "rose_build_dump.h"
 #include "rose_build_merge.h"
 #include "rose_build_role_aliasing.h"
 #include "rose_build_util.h"
 #include "ue2common.h"
-#include "nfa/castlecompile.h"
 #include "nfa/nfa_internal.h"
 #include "nfa/rdfa.h"
 #include "nfagraph/ng_holder.h"
@@ -46,7 +46,6 @@
 #include "nfagraph/ng_is_equal.h"
 #include "nfagraph/ng_limex.h"
 #include "nfagraph/ng_mcclellan.h"
-#include "nfagraph/ng_puff.h"
 #include "nfagraph/ng_repeat.h"
 #include "nfagraph/ng_reports.h"
 #include "nfagraph/ng_stop.h"
@@ -248,39 +247,38 @@ bool isUsedLiteral(const RoseBuildImpl &build, u32 lit_id) {
     return false;
 }
 
+/** \brief Allocate final literal IDs for all literals.
+ *
+ * These are the literal ids used in the bytecode.
+ */
 static
 void allocateFinalLiteralId(RoseBuildImpl &tbi) {
-    /* allocate final literal ids - these are the literal ids used in the
-     * bytecode.
-     * DRs already have special final ids allocated
-     */
-
     RoseGraph &g = tbi.g;
 
     set<u32> anch;
     set<u32> norm;
-    set<u32> norm_benefits;
     set<u32> delay;
 
     /* undelayed ids come first */
     assert(tbi.final_id_to_literal.empty());
     u32 next_final_id = 0;
     for (u32 i = 0; i < tbi.literal_info.size(); i++) {
-        if (tbi.hasFinalId(i)) {
-            continue;
-        }
+        assert(!tbi.hasFinalId(i));
 
         if (!isUsedLiteral(tbi, i)) {
             /* what is this literal good for? absolutely nothing */
             continue;
         }
 
-        const rose_literal_info &info = tbi.literal_info[i];
-        if (info.requires_benefits) {
-            assert(!tbi.isDelayed(i));
-            norm_benefits.insert(i);
-            DEBUG_PRINTF("%u has benefits\n", i);
-        } else if (tbi.isDelayed(i)) {
+        // The special EOD event literal has its own program and does not need
+        // a real literal ID.
+        if (i == tbi.eod_event_literal_id) {
+            assert(tbi.eod_event_literal_id != MO_INVALID_IDX);
+            continue;
+        }
+
+        if (tbi.isDelayed(i)) {
+            assert(!tbi.literal_info[i].requires_benefits);
             delay.insert(i);
         } else if (tbi.literals.right.at(i).table == ROSE_ANCHORED) {
             anch.insert(i);
@@ -289,12 +287,7 @@ void allocateFinalLiteralId(RoseBuildImpl &tbi) {
         }
     }
 
-    /* normal lits first (with benefits confirm)*/
-    allocateFinalIdToSet(g, norm_benefits, &tbi.literal_info,
-                         &tbi.final_id_to_literal, &next_final_id);
-
-    /* other normal lits (without benefits)*/
-    tbi.nonbenefits_base_id = next_final_id;
+    /* normal lits */
     allocateFinalIdToSet(g, norm, &tbi.literal_info, &tbi.final_id_to_literal,
                          &next_final_id);
 
@@ -309,51 +302,6 @@ void allocateFinalLiteralId(RoseBuildImpl &tbi) {
                          &next_final_id);
 }
 
-static
-void findDirectReports(RoseBuildImpl &tbi) {
-    const RoseGraph &g = tbi.g;
-
-    for (u32 i = 0; i < tbi.literal_info.size(); i++) {
-        if (!tbi.isDirectReport(i)) {
-            continue;
-        }
-
-        if (tbi.literals.right.at(i).table == ROSE_FLOATING) {
-            tbi.floating_direct_report = true;
-        }
-
-        rose_literal_info &info = tbi.literal_info[i];
-        const auto &verts = info.vertices;
-
-        assert(!verts.empty());
-        if (verts.size() == 1 && g[*verts.begin()].reports.size() == 1) {
-            // A single direct report. We set the high bit to indicate it's a
-            // direct report and encode the ReportID itself in the final_id
-            // field.
-            ReportID report = *(g[*verts.begin()].reports.begin());
-            assert(!(report & LITERAL_DR_FLAG));
-            info.final_id = LITERAL_DR_FLAG | report;
-        } else {
-            // A multi-direct report. Here we write the report set into a list
-            // to be triggered when we see this literal.
-            u32 mdr_index = verify_u32(tbi.mdr_reports.size());
-            info.final_id = LITERAL_MDR_FLAG | mdr_index;
-
-            // Temporary set for deduplication and determinism.
-            flat_set<ReportID> reports;
-
-            for (auto v : verts) {
-                insert(&reports, g[v].reports);
-            }
-            tbi.mdr_reports.insert(tbi.mdr_reports.end(), reports.begin(),
-                                   reports.end());
-            tbi.mdr_reports.push_back(MO_INVALID_IDX);
-        }
-
-        DEBUG_PRINTF("allocating final id %u to %u\n", info.final_id, i);
-    }
-}
-
 #define MAX_EXPLOSION_NC 3
 static
 bool limited_explosion(const ue2_literal &s) {
@@ -486,21 +434,6 @@ size_t trailerDueToSelf(const rose_literal_id &lit) {
     return trailer;
 }
 
-/* note: last byte cannot conflict as escapes are processed after other
- * lits at same offset */
-static
-bool conflictsWithEscape(const rose_literal_id &litv, const CharReach &cr) {
-    if (cr.none()) {
-        return false;
-    }
-
-    if (litv.delay) {
-        return true;
-    }
-
-    return contains(litv.s, cr);
-}
-
 static
 RoseRoleHistory findHistoryScheme(const RoseBuildImpl &tbi, const RoseEdge &e) {
     const RoseGraph &g = tbi.g;
@@ -611,21 +544,23 @@ bool RoseBuildImpl::isDirectReport(u32 id) const {
     // role's reports from a list.
 
     for (auto v : info.vertices) {
-        if (g[v].literals.size() != 1) {
-            return false; // Avoid roles with multiple literals at this stage.
-        }
-
-        assert(*g[v].literals.begin() == id);
+        assert(contains(g[v].literals, id));
 
         if (g[v].reports.empty() ||
             g[v].eod_accept || // no accept EOD
-            g[v].escapes.any() ||
             !g[v].isBoring() ||
             !isLeafNode(v, g) || // Must have no out-edges
             in_degree(v, g) != 1) { // Role must have exactly one in-edge
             return false;
         }
 
+        // Use the program to handle cases that aren't external reports.
+        for (const ReportID &id : g[v].reports) {
+            if (!isExternalReport(rm.getReport(id))) {
+                return false;
+            }
+        }
+
         if (literals.right.at(id).table == ROSE_ANCHORED) {
             /* in-edges are irrelevant for anchored region. */
             continue;
@@ -923,62 +858,10 @@ bool RoseBuildImpl::isDelayed(u32 id) const {
     return literal_info.at(id).undelayed_id != id;
 }
 
-bool RoseBuildImpl::hasDirectFinalId(u32 id) const {
-    return literal_info.at(id).final_id & LITERAL_MDR_FLAG;
-}
-
-bool RoseBuildImpl::hasDirectFinalId(RoseVertex v) const {
-    if (g[v].literals.empty()) {
-        return false;
-    }
-    return hasDirectFinalId(*g[v].literals.begin());
-}
-
 bool RoseBuildImpl::hasFinalId(u32 id) const {
     return literal_info.at(id).final_id != MO_INVALID_IDX;
 }
 
-static
-void doSidecarLiterals(RoseBuildImpl &tbi) {
-    map<CharReach, set<RoseVertex> > escapes;
-    const RoseGraph &g = tbi.g;
-
-    /* find escapes */
-    for (auto v : vertices_range(g)) {
-        const CharReach &cr = g[v].escapes;
-        if (cr.none()) {
-            continue;
-        }
-
-        DEBUG_PRINTF("vertex %zu has %zu escapes\n", g[v].idx, cr.count());
-
-        // We only have an implementation for these escapes if the Sidecar is
-        // available for use.
-        assert(tbi.cc.grey.allowSidecar);
-
-        assert(!isLeafNode(v, g));
-
-        /* Verify that all the successors are floating */
-        for (UNUSED auto w : adjacent_vertices_range(v, g)) {
-            assert(!tbi.isAnchored(w));
-        }
-
-        escapes[cr].insert(v);
-    }
-
-    if (escapes.size() > 32) {
-        /* ensure that a most one sparse iterator is triggered per char */
-        escapes = make_disjoint(escapes);
-    }
-
-    /* create the squash/escape sidecar entries for the vertices and associate
-     * with appropriate roles */
-    for (const auto &e : escapes) {
-        const CharReach &cr = e.first;
-        insert(&tbi.side_squash_roles[cr], e.second);
-    }
-}
-
 static
 bool eligibleForAlwaysOnGroup(const RoseBuildImpl &tbi, u32 id) {
     /* returns true if it or any of its delay versions have root role */
@@ -1311,42 +1194,6 @@ bool coversGroup(const RoseBuildImpl &tbi, const rose_literal_info &lit_info) {
     return true;
 }
 
-static
-bool escapesAllPreds(const RoseGraph &g, RoseVertex v, const CharReach &cr) {
-    for (auto u : inv_adjacent_vertices_range(v, g)) {
-        if ((~g[u].escapes & cr).any()) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static
-bool mayNotSeeSubsequentPredsInOrder(const RoseBuildImpl &tbi, RoseVertex v) {
-    const RoseGraph &g = tbi.g;
-
-    if (in_degree(v, g) == 1) {
-        /* if the pred can only match once, there are no subsequent preds */
-        RoseVertex u = source(*in_edges(v, g).first, g);
-        if (g[u].max_offset == g[u].min_offset) {
-            return false;
-        }
-    }
-
-    for (auto u : inv_adjacent_vertices_range(v, g)) {
-        for (u32 lit_id : g[u].literals) {
-            const rose_literal_id &lit = tbi.literals.right.at(lit_id);
-            if (lit.table == ROSE_ANCHORED) {
-                return true;
-            }
-        }
-
-    }
-
-    return false;
-}
-
 static
 bool isGroupSquasher(const RoseBuildImpl &tbi, const u32 id /* literal id */,
                      rose_group forbidden_squash_group) {
@@ -1403,35 +1250,6 @@ bool isGroupSquasher(const RoseBuildImpl &tbi, const u32 id /* literal id */,
             return false;
         }
 
-        /* Can only squash cases with escapes if all preds have the same escapes
-         * and none of the literals overlap with the escape
-         *
-         * Additionally, if we may not see one of the preds in time to turn on
-         * the group again we have problems.
-         *
-         * ARGHHHH
-         */
-        if (g[v].escapes.any()) {
-            if (!escapesAllPreds(g, v, g[v].escapes)
-                || mayNotSeeSubsequentPredsInOrder(tbi, v)) {
-                return false;
-            }
-
-            if (g[v].literals.size() == 1) {
-                if (conflictsWithEscape(tbi.literals.right.at(id),
-                                        g[v].escapes)) {
-                    return false;
-                }
-            } else {
-                for (const auto &lit_id : g[v].literals) {
-                    const rose_literal_id &lit = tbi.literals.right.at(lit_id);
-                    if (lit.delay || contains(lit.s, g[v].escapes)) {
-                        return false;
-                    }
-                }
-            }
-        }
-
         // Out-edges must have inf max bound, + no other shenanigans */
         for (const auto &e : out_edges_range(v, g)) {
             if (g[e].maxBound != ROSE_BOUND_INF) {
@@ -1454,9 +1272,8 @@ bool isGroupSquasher(const RoseBuildImpl &tbi, const u32 id /* literal id */,
     for (auto v : lit_info.vertices) {
         assert(!tbi.isAnyStart(v));
 
-        // Can't squash cases with accepts or escapes
-        if (!g[v].reports.empty()
-            || (g[v].escapes.any() && !escapesAllPreds(g, v, g[v].escapes))) {
+        // Can't squash cases with accepts
+        if (!g[v].reports.empty()) {
             return false;
         }
 
@@ -1606,24 +1423,6 @@ map<left_id, vector<RoseVertex>> findLeftSucc(RoseBuildImpl &tbi) {
     return leftfixes;
 }
 
-static
-ue2_literal findNonOverlappingTail(const set<ue2_literal> &lits,
-                                   const ue2_literal &s) {
-    size_t max_overlap = 0;
-
-    for (const auto &lit : lits) {
-        size_t overlap = lit != s ? maxStringOverlap(lit, s)
-                                  : maxStringSelfOverlap(s);
-        max_overlap = max(max_overlap, overlap);
-    }
-
-    /* find the tail that doesn't overlap */
-    ue2_literal tail = s.substr(max_overlap);
-    DEBUG_PRINTF("%zu overlap, tail: '%s'\n", max_overlap,
-                 dumpString(tail).c_str());
-    return tail;
-}
-
 static
 bool triggerKillsRoseGraph(const RoseBuildImpl &tbi, const left_id &left,
                            const set<ue2_literal> &all_lits,
@@ -1657,47 +1456,6 @@ bool triggerKillsRoseGraph(const RoseBuildImpl &tbi, const left_id &left,
     return true;
 }
 
-static
-bool triggerKillsRoseCastle(const RoseBuildImpl &tbi, const left_id &left,
-                            const set<ue2_literal> &all_lits,
-                            const RoseEdge &e) {
-    assert(left.castle());
-    const CastleProto &c = *left.castle();
-
-    const depth max_width = findMaxWidth(c);
-    DEBUG_PRINTF("castle max width is %s\n", max_width.str().c_str());
-
-    /* check each pred literal to see if they all kill previous castle
-     * state */
-    for (u32 lit_id : tbi.g[source(e, tbi.g)].literals) {
-        const rose_literal_id &pred_lit = tbi.literals.right.at(lit_id);
-        const ue2_literal s = findNonOverlappingTail(all_lits, pred_lit.s);
-        const CharReach &cr = c.reach();
-
-        DEBUG_PRINTF("s=%s, castle reach=%s\n", dumpString(s).c_str(),
-                      describeClass(cr).c_str());
-
-        for (const auto &s_cr : s) {
-            if (!overlaps(cr, s_cr)) {
-                DEBUG_PRINTF("reach %s kills castle\n",
-                             describeClass(s_cr).c_str());
-                goto next_pred;
-            }
-        }
-
-        if (max_width < depth(s.length())) {
-            DEBUG_PRINTF("literal width >= castle max width\n");
-            goto next_pred;
-        }
-
-        return false;
-
-    next_pred:;
-    }
-
-    return true;
-}
-
 static
 bool triggerKillsRose(const RoseBuildImpl &tbi, const left_id &left,
                       const set<ue2_literal> &all_lits, const RoseEdge &e) {
@@ -1968,7 +1726,6 @@ void addSmallBlockLiteral(RoseBuildImpl &tbi, const simple_anchored_info &sai,
             // Clone vertex with the new literal ID.
             RoseVertex v = add_vertex(g[lit_v], g);
             g[v].idx = tbi.vertexIndex++;
-            g[v].escapes.clear();
             g[v].literals.clear();
             g[v].literals.insert(lit_id);
             g[v].min_offset = sai.min_bound + sai.literal.length();
@@ -2147,8 +1904,8 @@ bool extractSEPLiterals(const OutfixInfo &outfix, const ReportManager &rm,
     // SEP cases should always become DFAs, so that's the only extract code we
     // have implemented here.
 
-    if (outfix.rdfa) {
-        return extractSEPLiterals(*outfix.rdfa, lits_out);
+    if (outfix.rdfa()) {
+        return extractSEPLiterals(*outfix.rdfa(), lits_out);
     }
 
     DEBUG_PRINTF("cannot extract literals from outfix type\n");
@@ -2231,232 +1988,6 @@ void addAnchoredSmallBlockLiterals(RoseBuildImpl &tbi) {
     }
 }
 
-static
-void makeCastle(LeftEngInfo &left,
-        ue2::unordered_map<const NGHolder *, shared_ptr<CastleProto> > &cache) {
-    if (left.dfa || left.haig || left.castle) {
-        return;
-    }
-    if (!left.graph) {
-        return;
-    }
-
-    const NGHolder &h = *left.graph;
-    DEBUG_PRINTF("prefix %p\n", &h);
-
-    if (contains(cache, &h)) {
-        DEBUG_PRINTF("using cached CastleProto\n");
-        left.castle = cache[&h];
-        left.graph.reset();
-        return;
-    }
-
-    PureRepeat pr;
-    if (isPureRepeat(h, pr) && pr.reports.size() == 1) {
-        DEBUG_PRINTF("vertex preceded by infix repeat %s\n",
-                     pr.bounds.str().c_str());
-        left.castle = make_shared<CastleProto>(pr);
-        cache[&h] = left.castle;
-        left.graph.reset();
-    }
-}
-
-static
-void makeCastleSuffix(RoseBuildImpl &tbi, RoseVertex v,
-        ue2::unordered_map<const NGHolder *, shared_ptr<CastleProto> > &cache) {
-    RoseSuffixInfo &suffix = tbi.g[v].suffix;
-    if (!suffix.graph) {
-        return;
-    }
-    const NGHolder &h = *suffix.graph;
-    DEBUG_PRINTF("suffix %p\n", &h);
-
-    if (contains(cache, &h)) {
-        DEBUG_PRINTF("using cached CastleProto\n");
-        suffix.castle = cache[&h];
-        suffix.graph.reset();
-        return;
-    }
-
-    // The MPV will probably do a better job on the cases it's designed
-    // for.
-    const bool fixed_depth = tbi.g[v].min_offset == tbi.g[v].max_offset;
-    if (isPuffable(h, fixed_depth, tbi.rm, tbi.cc.grey)) {
-        DEBUG_PRINTF("leaving suffix for puff\n");
-        return;
-    }
-
-    PureRepeat pr;
-    if (isPureRepeat(h, pr) && pr.reports.size() == 1) {
-        DEBUG_PRINTF("suffix repeat %s\n", pr.bounds.str().c_str());
-
-        // Right now, the Castle uses much more stream state to represent a
-        // {m,1} repeat than just leaving it to an NFA.
-        if (pr.bounds.max <= depth(1)) {
-            DEBUG_PRINTF("leaving for other engines\n");
-            return;
-        }
-
-        suffix.castle = make_shared<CastleProto>(pr);
-        cache[&h] = suffix.castle;
-        suffix.graph.reset();
-    }
-}
-
-/**
- * Runs over all rose infix/suffix engines and converts those that are pure
- * repeats with one report into CastleProto engines.
- */
-static
-void makeCastles(RoseBuildImpl &tbi) {
-    if (!tbi.cc.grey.allowCastle && !tbi.cc.grey.allowLbr) {
-        return;
-    }
-
-    RoseGraph &g = tbi.g;
-
-    // Caches so that we can reuse analysis on graphs we've seen already.
-    ue2::unordered_map<const NGHolder *, shared_ptr<CastleProto> > left_cache;
-    ue2::unordered_map<const NGHolder *, shared_ptr<CastleProto> > suffix_cache;
-
-    for (auto v : vertices_range(g)) {
-        if (g[v].left && !tbi.isRootSuccessor(v)) {
-            makeCastle(g[v].left, left_cache);
-        }
-
-        if (g[v].suffix) {
-            makeCastleSuffix(tbi, v, suffix_cache);
-        }
-    }
-}
-
-/**
- * Identifies all the CastleProto prototypes that are small enough that they
- * would be better implemented as NFAs, and converts them back to NGHolder
- * prototypes.
- *
- * Returns true if any changes were made.
- */
-static
-bool unmakeCastles(RoseBuildImpl &tbi) {
-    RoseGraph &g = tbi.g;
-
-    const size_t MAX_UNMAKE_VERTICES = 64;
-
-    map<left_id, vector<RoseVertex> > left_castles;
-    map<suffix_id, vector<RoseVertex> > suffix_castles;
-    bool changed = false;
-
-    for (auto v : vertices_range(g)) {
-        const LeftEngInfo &left = g[v].left;
-        if (left.castle && left.castle->repeats.size() > 1) {
-            left_castles[left].push_back(v);
-        }
-        const RoseSuffixInfo &suffix = g[v].suffix;
-        if (suffix.castle && suffix.castle->repeats.size() > 1) {
-            suffix_castles[suffix].push_back(v);
-        }
-    }
-
-    for (const auto &e : left_castles) {
-        assert(e.first.castle());
-        shared_ptr<NGHolder> h = makeHolder(*e.first.castle(), NFA_INFIX,
-                                            tbi.cc);
-        if (!h || num_vertices(*h) > MAX_UNMAKE_VERTICES) {
-            continue;
-        }
-        DEBUG_PRINTF("replace rose with holder (%zu vertices)\n",
-                     num_vertices(*h));
-        for (auto v : e.second) {
-            assert(g[v].left.castle.get() == e.first.castle());
-            g[v].left.graph = h;
-            g[v].left.castle.reset();
-            changed = true;
-        }
-    }
-
-    for (const auto &e : suffix_castles) {
-        assert(e.first.castle());
-        shared_ptr<NGHolder> h = makeHolder(*e.first.castle(), NFA_SUFFIX,
-                                            tbi.cc);
-        if (!h || num_vertices(*h) > MAX_UNMAKE_VERTICES) {
-            continue;
-        }
-        DEBUG_PRINTF("replace suffix with holder (%zu vertices)\n",
-                     num_vertices(*h));
-        for (auto v : e.second) {
-            assert(g[v].suffix.castle.get() == e.first.castle());
-            g[v].suffix.graph = h;
-            g[v].suffix.castle.reset();
-            changed = true;
-        }
-    }
-
-    return changed;
-}
-
-/**
- * Runs over all the Castle engine prototypes in the graph and ensures that
- * they have tops in a contiguous range, ready for construction.
- */
-static
-void remapCastleTops(RoseBuildImpl &tbi) {
-    ue2::unordered_map<CastleProto *, vector<RoseVertex> > rose_castles;
-    ue2::unordered_map<CastleProto *, vector<RoseVertex> > suffix_castles;
-
-    RoseGraph &g = tbi.g;
-    for (auto v : vertices_range(g)) {
-        if (g[v].left.castle) {
-            rose_castles[g[v].left.castle.get()].push_back(v);
-        }
-        if (g[v].suffix.castle) {
-            suffix_castles[g[v].suffix.castle.get()].push_back(v);
-        }
-    }
-
-    DEBUG_PRINTF("%zu rose castles, %zu suffix castles\n", rose_castles.size(),
-                  suffix_castles.size());
-
-    map<u32, u32> top_map;
-
-    // Remap Rose Castles.
-    for (const auto &rc : rose_castles) {
-        CastleProto *c = rc.first;
-        const vector<RoseVertex> &verts = rc.second;
-
-        DEBUG_PRINTF("rose castle %p (%zu repeats) has %zu verts\n", c,
-                      c->repeats.size(), verts.size());
-
-        top_map.clear();
-        remapCastleTops(*c, top_map);
-
-        // Update the tops on the edges leading into vertices in v.
-        for (auto v : verts) {
-            for (const auto &e : in_edges_range(v, g)) {
-                g[e].rose_top = top_map.at(g[e].rose_top);
-            }
-        }
-    }
-
-    // Remap Suffix Castles.
-    for (const auto &e : suffix_castles) {
-        CastleProto *c = e.first;
-        const vector<RoseVertex> &verts = e.second;
-
-        DEBUG_PRINTF("suffix castle %p (%zu repeats) has %zu verts\n", c,
-                      c->repeats.size(), verts.size());
-
-        top_map.clear();
-        remapCastleTops(*c, top_map);
-
-        // Update the tops on the suffixes.
-        for (auto v : verts) {
-            assert(g[v].suffix);
-            g[v].suffix.top = top_map.at(g[v].suffix.top);
-        }
-    }
-}
-
 #ifndef NDEBUG
 static
 bool historiesAreValid(const RoseGraph &g) {
@@ -2564,53 +2095,6 @@ bool hasOrphanedTops(const RoseBuildImpl &tbi) {
 
 #endif // NDEBUG
 
-/**
- * \brief Normalise vertices so that every one has <= 1 report.
- */
-static
-void normaliseRoles(RoseBuildImpl &build) {
-    DEBUG_PRINTF("normalising\n");
-    RoseGraph &g = build.g;
-
-    vector<RoseVertex> work; // Vertices with > 1 report.
-
-    for (const auto &v : vertices_range(g)) {
-        if (g[v].reports.size() > 1) {
-            work.push_back(v);
-        }
-    }
-
-    DEBUG_PRINTF("%zu vertices to normalise\n", work.size());
-
-    for (const auto &v : work) {
-        DEBUG_PRINTF("exploding vertex %zu with %zu reports\n", g[v].idx,
-                     g[v].reports.size());
-
-        // Make a copy of v for the trailing N-1 reports. Each of those gets
-        // one report and a copy of the in-edges. The first vertex retains the
-        // out-edges and suffix, if any are present. All the others don't need
-        // them.
-
-        const auto &reports = g[v].reports;
-
-        for (auto it = next(begin(reports)); it != end(reports); ++it) {
-            const ReportID &r = *it;
-            RoseVertex v2 = build.cloneVertex(v);
-            g[v2].reports = {r};
-
-            for (const auto &e : in_edges_range(v, g)) {
-                add_edge(source(e, g), v2, g[e], g);
-            }
-
-            // No out-edges or suffix.
-            g[v2].suffix.reset();
-        }
-
-        // Vertex v retains the first report.
-        g[v].reports = {*begin(reports)};
-    }
-}
-
 aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildRose(u32 minWidth) {
     dumpRoseGraph(*this, nullptr, "rose_early.dot");
 
@@ -2632,9 +2116,8 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildRose(u32 minWidth) {
 
     // If we've got a very small number of EOD-anchored literals, consider
     // moving them into the floating table so that we only have one literal
-    // matcher to run. Note that this should happen before findDirectReports as
-    // it modifies the literal/vertex set. Note also that this needs to happen
-    // before addAnchoredSmallBlockLiterals as it may create anchored literals.
+    // matcher to run. Note that this needs to happen before
+    // addAnchoredSmallBlockLiterals as it may create anchored literals.
     assert(roleOffsetsAreValid(g));
     stealEodVertices(*this);
 
@@ -2650,8 +2133,6 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildRose(u32 minWidth) {
     assert(roleOffsetsAreValid(g));
     handleMixedSensitivity();
 
-    findDirectReports(*this);
-
     assignHistories(*this);
 
     convertAnchPrefixToBounds(*this);
@@ -2704,9 +2185,6 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildRose(u32 minWidth) {
     assignGroupsToRoles();
     findGroupSquashers(*this);
 
-    // Collect squash literals for the sidecar
-    doSidecarLiterals(*this);
-
     /* final prep work */
     remapCastleTops(*this);
     allocateFinalLiteralId(*this);
@@ -2728,10 +2206,6 @@ aligned_unique_ptr<RoseEngine> RoseBuildImpl::buildRose(u32 minWidth) {
 
     dumpRoseGraph(*this, nullptr, "rose_pre_norm.dot");
 
-    // Ensure that every vertex has <= 1 report, since the Rose runtime
-    // requires this at present.
-    normaliseRoles(*this);
-
     return buildFinalEngine(minWidth);
 }
 
diff --git a/src/rose/rose_build_convert.cpp b/src/rose/rose_build_convert.cpp
index 8dccf047..f5e99c23 100644
--- a/src/rose/rose_build_convert.cpp
+++ b/src/rose/rose_build_convert.cpp
@@ -123,12 +123,12 @@ static
 unique_ptr<NGHolder> convertLeafToHolder(const RoseGraph &g,
                                          const RoseEdge &t_e,
                                          const RoseLiteralMap &literals) {
-    RoseVertex t_u = source(t_e, g);
     RoseVertex t_v = target(t_e, g); // leaf vertex for demolition.
-    const CharReach escape_cr(~g[t_u].escapes);
     u32 minBound = g[t_e].minBound;
     u32 maxBound = g[t_e].maxBound;
 
+    const CharReach dot = CharReach::dot();
+
     assert(!g[t_v].left);
 
     auto out = ue2::make_unique<NGHolder>(NFA_SUFFIX);
@@ -138,14 +138,14 @@ unique_ptr<NGHolder> convertLeafToHolder(const RoseGraph &g,
     u32 i = 1;
     NFAVertex last = out->start;
     for (; i <= minBound; i++) {
-        NFAVertex v = addHolderVertex(escape_cr, *out);
+        NFAVertex v = addHolderVertex(dot, *out);
         add_edge(last, v, *out);
         last = v;
     }
     NFAVertex last_mand = last;
     if (maxBound != ROSE_BOUND_INF) {
         for (; i <= maxBound; i++) {
-            NFAVertex v = addHolderVertex(escape_cr, *out);
+            NFAVertex v = addHolderVertex(dot, *out);
             add_edge(last_mand, v, *out);
             if (last != last_mand) {
                 add_edge(last, v, *out);
@@ -156,7 +156,7 @@ unique_ptr<NGHolder> convertLeafToHolder(const RoseGraph &g,
         if (minBound) {
             add_edge(last_mand, last_mand, *out);
         } else {
-            NFAVertex v = addHolderVertex(escape_cr, *out);
+            NFAVertex v = addHolderVertex(dot, *out);
             add_edge(last_mand, v, *out);
             add_edge(v, v, *out);
             last = v;
@@ -277,28 +277,10 @@ bool isUnconvertibleLeaf(const RoseBuildImpl &tbi, const RoseVertex v) {
         return true;
     }
 
-    /* more arbitrary magic numbers as riskier transform */
     if (g[e].maxBound == ROSE_BOUND_INF) {
-        if (!tbi.cc.grey.roseConvertInfBadLeaves) {
-            return true;
-        }
-
-        if (g[e].minBound > 20) {
-            DEBUG_PRINTF("fail minbound (%u)\n", maxbound);
-            return true;
-        }
-
-        if (max_lit_len > 2) {
-            DEBUG_PRINTF("fail length\n");
-            return true;
-        }
-
-        if (g[u].escapes.none()) {
-            /* slightly risky as nfa won't die and we don't avoid running the
-               sidecar */
-            DEBUG_PRINTF("fail: .*\n");
-            return true;
-        }
+        /* slightly risky as nfa won't die */
+        DEBUG_PRINTF("fail: .*\n");
+        return true;
     }
 
     return false;
@@ -386,7 +368,6 @@ void convertBadLeaves(RoseBuildImpl &tbi) {
 
         RoseVertex u = source(e, g);
         assert(!g[u].suffix);
-        g[u].escapes = CharReach();
         g[u].suffix.graph = h;
         DEBUG_PRINTF("%zu's nfa holder %p\n", g[u].idx, h.get());
 
@@ -1115,12 +1096,19 @@ void convertAnchPrefixToBounds(RoseBuildImpl &tbi) {
 
         const PureRepeat &pr = castle.repeats.begin()->second;
         DEBUG_PRINTF("castle has repeat %s\n", pr.bounds.str().c_str());
+        DEBUG_PRINTF("delay adj %u\n", (u32)delay_adj);
+
+        if (delay_adj >= pr.bounds.max) {
+            DEBUG_PRINTF("delay adj too large\n");
+            continue;
+        }
 
         DepthMinMax bounds(pr.bounds); // copy
         if (delay_adj > bounds.min) {
-            delay_adj = bounds.min;
+            bounds.min = 0;
+        } else {
+            bounds.min -= delay_adj;
         }
-        bounds.min -= delay_adj;
         bounds.max -= delay_adj;
 
         g[e].minBound = bounds.min;
diff --git a/src/rose/rose_build_dump.cpp b/src/rose/rose_build_dump.cpp
index e36c54a2..079dd556 100644
--- a/src/rose/rose_build_dump.cpp
+++ b/src/rose/rose_build_dump.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -32,6 +32,7 @@
 
 #include "hwlm/hwlm_build.h"
 #include "rose_build_impl.h"
+#include "rose_build_matchers.h"
 #include "rose/rose_dump.h"
 #include "rose_internal.h"
 #include "ue2common.h"
@@ -72,29 +73,13 @@ string to_string(nfa_kind k) {
         return "o";
     case NFA_REV_PREFIX:
         return "r";
+    case NFA_OUTFIX_RAW:
+        return "O";
     }
     assert(0);
     return "?";
 }
 
-// Get the RoseRole associated with a given vertex in the build graph from the
-// RoseEngine.
-static
-const RoseRole *getRoseRole(const RoseBuildImpl &build,
-                            const RoseEngine *engine, RoseVertex v) {
-    if (!engine) {
-        return nullptr;
-    }
-
-    u32 role_idx = build.g[v].role;
-    if (role_idx == MO_INVALID_IDX) {
-        return nullptr;
-    }
-
-    const RoseRole *roles = getRoleTable(engine);
-    return &roles[role_idx];
-}
-
 namespace {
 
 class RoseGraphWriter {
@@ -120,7 +105,7 @@ public:
         }
 
         os << "[label=\"";
-        os << "role=" << g[v].role << "[i" << g[v].idx <<"]\\n";
+        os << "idx=" << g[v].idx <<"\\n";
 
         for (u32 lit_id : g[v].literals) {
             writeLiteral(os, lit_id);
@@ -144,47 +129,26 @@ public:
             os << " (rep=" << as_string_list(g[v].reports) << ")";
         }
 
-        const RoseRole *r = getRoseRole(v);
-
         if (g[v].suffix) {
             os << "\\nSUFFIX (TOP " << g[v].suffix.top;
-            if (r) {
-                assert(t);
-                const NFA *n = (const NFA *)((const char *)t + r->suffixOffset);
-                os << ", Q" << n->queueIndex;
-            } else {
-                // Can't dump the queue number, but we can identify the suffix.
-                if (g[v].suffix.graph) {
-                    os << ", graph=" << g[v].suffix.graph.get()
-                       << " " << to_string(g[v].suffix.graph->kind);
-                }
-                if (g[v].suffix.castle) {
-                    os << ", castle=" << g[v].suffix.castle.get();
-                }
-                if (g[v].suffix.rdfa) {
-                    os << ", dfa=" << g[v].suffix.rdfa.get();
-                }
-                if (g[v].suffix.haig) {
-                    os << ", haig=" << g[v].suffix.haig.get();
-                }
-
+            // Can't dump the queue number, but we can identify the suffix.
+            if (g[v].suffix.graph) {
+                os << ", graph=" << g[v].suffix.graph.get() << " "
+                   << to_string(g[v].suffix.graph->kind);
             }
+            if (g[v].suffix.castle) {
+                os << ", castle=" << g[v].suffix.castle.get();
+            }
+            if (g[v].suffix.rdfa) {
+                os << ", dfa=" << g[v].suffix.rdfa.get();
+            }
+            if (g[v].suffix.haig) {
+                os << ", haig=" << g[v].suffix.haig.get();
+            }
+
             os << ")";
         }
 
-        if (!g[v].literals.empty()) {
-            u32 id = *g[v].literals.begin();
-            if (id < build.literal_info.size()
-                && build.literal_info[id].final_id != MO_INVALID_IDX
-                && (build.literal_info[id].final_id & LITERAL_DR_FLAG)) {
-                os << "\\nDIRECT REPORT";
-            }
-        }
-
-        if (g[v].escapes.any()) {
-            os << "\\nescapes=";
-            describeClass(os, g[v].escapes, 5, CC_OUT_DOT);
-        }
         if (ghost.find(v) != ghost.end()) {
             os << "\\nGHOST";
         }
@@ -194,10 +158,6 @@ public:
                 build.isRootSuccessor(v) ? "PREFIX" : "INFIX";
             os << "\\nROSE " << roseKind;
             os << " (";
-            if (r) {
-                os << "Q" << r->leftfixQueue << ", ";
-            }
-
             os << "report " << g[v].left.leftfix_report << ")";
 
             if (g[v].left.graph) {
@@ -290,10 +250,6 @@ private:
         }
     }
 
-    const RoseRole *getRoseRole(RoseVertex v) const {
-        return ue2::getRoseRole(build, t, v);
-    }
-
     set<RoseVertex> ghost;
     const RoseBuildImpl &build;
     const RoseEngine *t;
@@ -325,7 +281,7 @@ namespace {
 struct CompareVertexRole {
     explicit CompareVertexRole(const RoseGraph &g_in) : g(g_in) {}
     inline bool operator()(const RoseVertex &a, const RoseVertex &b) const {
-        return g[a].role < g[b].role;
+        return g[a].idx < g[b].idx;
     }
 private:
     const RoseGraph &g;
@@ -354,8 +310,6 @@ void dumpRoseLiterals(const RoseBuildImpl &build, const char *filename) {
     os << "ROSE LITERALS: a total of " << build.literals.right.size()
        << " literals and " << num_vertices(g) << " roles." << endl << endl;
 
-    const auto depths = findDepths(build);
-
     for (const auto &e : build.literals.right) {
         u32 id = e.first;
         const ue2_literal &s = e.second.s;
@@ -425,9 +379,8 @@ void dumpRoseLiterals(const RoseBuildImpl &build, const char *filename) {
 
         for (RoseVertex v : verts) {
             // role info
-            os << "  Role " << g[v].role << ": depth=" << depths.at(v)
-               << ", groups=0x" << hex << setw(16) << setfill('0')
-               << g[v].groups << dec;
+            os << "  Index " << g[v].idx << ": groups=0x" << hex << setw(16)
+               << setfill('0') << g[v].groups << dec;
 
             if (g[v].reports.empty()) {
                 os << ", report=NONE";
@@ -439,14 +392,14 @@ void dumpRoseLiterals(const RoseBuildImpl &build, const char *filename) {
             os << ", max_offset=" << g[v].max_offset << endl;
             // pred info
             for (const auto &ie : in_edges_range(v, g)) {
-                os << "    Predecessor role=";
-                u32 predRole = g[source(ie, g)].role;
-                if (predRole == MO_INVALID_IDX) {
+                const auto &u = source(ie, g);
+                os << "    Predecessor idx=";
+                if (u == build.root) {
                     os << "ROOT";
-                } else if (predRole == g[build.anchored_root].role) {
+                } else if (u == build.anchored_root) {
                     os << "ANCHORED_ROOT";
                 } else {
-                    os << predRole;
+                    os << g[u].idx;
                 }
                 os << ": bounds [" << g[ie].minBound << ", ";
                 if (g[ie].maxBound == ROSE_BOUND_INF) {
@@ -508,84 +461,24 @@ struct LongerThanLimit {
 
 static
 void dumpRoseTestLiterals(const RoseBuildImpl &build, const string &base) {
-
-    vector<hwlmLiteral> lits;
-
-    fillHamsterLiteralList(build, ROSE_ANCHORED, &lits);
+    auto lits = fillHamsterLiteralList(build, ROSE_ANCHORED);
     dumpTestLiterals(base + "rose_anchored_test_literals.txt", lits);
 
-    lits.clear();
-    fillHamsterLiteralList(build, ROSE_FLOATING, &lits);
+    lits = fillHamsterLiteralList(build, ROSE_FLOATING);
     dumpTestLiterals(base + "rose_float_test_literals.txt", lits);
 
-    lits.clear();
-    fillHamsterLiteralList(build, ROSE_EOD_ANCHORED, &lits);
+    lits = fillHamsterLiteralList(build, ROSE_EOD_ANCHORED);
     dumpTestLiterals(base + "rose_eod_test_literals.txt", lits);
 
-    lits.clear();
-    fillHamsterLiteralList(build, ROSE_FLOATING, &lits);
-    fillHamsterLiteralList(build, ROSE_ANCHORED_SMALL_BLOCK, &lits);
+    lits = fillHamsterLiteralList(build, ROSE_FLOATING);
+    auto lits2 = fillHamsterLiteralList(build, ROSE_ANCHORED_SMALL_BLOCK);
+    lits.insert(end(lits), begin(lits2), end(lits2));
     lits.erase(remove_if(lits.begin(), lits.end(),
                          LongerThanLimit(ROSE_SMALL_BLOCK_LEN)),
                lits.end());
     dumpTestLiterals(base + "rose_smallblock_test_literals.txt", lits);
 }
 
-static
-CharReach bitvectorToReach(const u8 *reach) {
-    CharReach cr;
-
-    for (size_t i = 0; i < 256; i++) {
-        if (reach[i / 8] & (1U << (i % 8))) {
-            cr.set(i);
-
-        }
-    }
-    return cr;
-}
-
-static
-void dumpRoseLookaround(const RoseBuildImpl &build, const RoseEngine *t,
-                        const Grey &grey, const string &filename) {
-    stringstream ss;
-    ss << grey.dumpPath << filename;
-    ofstream os(ss.str());
-
-    const RoseGraph &g = build.g;
-
-    const u8 *base = (const u8 *)t;
-    const s8 *look_base = (const s8 *)(base + t->lookaroundTableOffset);
-    const u8 *reach_base = base + t->lookaroundReachOffset;
-
-    for (RoseVertex v : vertices_range(g)) {
-        const RoseRole *role = getRoseRole(build, t, v);
-        if (!role || role->lookaroundIndex == MO_INVALID_IDX) {
-            continue;
-        }
-
-        os << "Role " << g[v].role << endl;
-        os << "  literals: " << as_string_list(g[v].literals) << endl;
-        os << "  lookaround: index=" << role->lookaroundIndex
-           << ", count=" << role->lookaroundCount << endl;
-
-        const s8 *look = look_base + role->lookaroundIndex;
-        const s8 *look_end = look + role->lookaroundCount;
-        const u8 *reach =
-            reach_base + role->lookaroundIndex * REACH_BITVECTOR_LEN;
-
-        for (; look < look_end; look++, reach += REACH_BITVECTOR_LEN) {
-            os << "    " << std::setw(4) << std::setfill(' ') << int{*look}
-               << ": ";
-            describeClass(os, bitvectorToReach(reach), 1000, CC_OUT_TEXT);
-            os << endl;
-        }
-
-        os << endl;
-    }
-
-    os.close();
-}
-
 void dumpRose(const RoseBuild &build_base, const RoseEngine *t,
               const Grey &grey) {
     if (!grey.dumpFlags) {
@@ -625,9 +518,6 @@ void dumpRose(const RoseBuild &build_base, const RoseEngine *t,
     f = fopen((grey.dumpPath + "/rose_struct.txt").c_str(), "w");
     roseDumpStructRaw(t, f);
     fclose(f);
-
-    // Lookaround tables.
-    dumpRoseLookaround(build, t, grey, "rose_lookaround.txt");
 }
 
 } // namespace ue2
diff --git a/src/rose/rose_build_impl.h b/src/rose/rose_build_impl.h
index 3112d639..4122e0bd 100644
--- a/src/rose/rose_build_impl.h
+++ b/src/rose/rose_build_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -48,6 +48,7 @@
 #include <vector>
 #include <boost/bimap.hpp>
 #include <boost/functional/hash/hash.hpp>
+#include <boost/variant.hpp>
 
 struct RoseEngine;
 
@@ -58,7 +59,6 @@ namespace ue2 {
 struct BoundaryReports;
 struct CastleProto;
 struct CompileContext;
-struct hwlmLiteral;
 class ReportManager;
 class SomSlotManager;
 
@@ -291,53 +291,100 @@ bool operator<(const simple_anchored_info &a, const simple_anchored_info &b) {
     return 0;
 }
 
-struct OutfixInfo { /* TODO: poly */
-    OutfixInfo() {}
-    explicit OutfixInfo(std::unique_ptr<raw_dfa> r) : rdfa(std::move(r)) {
-        assert(rdfa);
+struct MpvProto {
+    bool empty() const {
+        return puffettes.empty() && triggered_puffettes.empty();
     }
-    explicit OutfixInfo(std::unique_ptr<NGHolder> h) : holder(std::move(h)) {
-        assert(holder);
-    }
-    explicit OutfixInfo(std::unique_ptr<raw_som_dfa> r) : haig(std::move(r)) {
-        assert(haig);
+    void reset() {
+        puffettes.clear();
+        triggered_puffettes.clear();
     }
+    std::vector<raw_puff> puffettes;
+    std::vector<raw_puff> triggered_puffettes;
+};
+
+struct OutfixInfo {
+    template<class T>
+    explicit OutfixInfo(std::unique_ptr<T> x) : proto(std::move(x)) {}
+
+    explicit OutfixInfo(MpvProto mpv) : proto(std::move(mpv)) {}
 
     u32 get_queue(QueueIndexFactory &qif);
 
+    u32 get_queue() const {
+        assert(queue != ~0U);
+        return queue;
+    }
+
     bool is_nonempty_mpv() const {
-        return !puffettes.empty() || !triggered_puffettes.empty();
+        auto *mpv = boost::get<MpvProto>(&proto);
+        return mpv && !mpv->empty();
     }
 
     bool is_dead() const {
-        return !holder && !rdfa && !haig && puffettes.empty() &&
-               triggered_puffettes.empty();
+        auto *mpv = boost::get<MpvProto>(&proto);
+        if (mpv) {
+            return mpv->empty();
+        }
+        return boost::get<boost::blank>(&proto) != nullptr;
     }
 
     void clear() {
-        holder.reset();
-        rdfa.reset();
-        haig.reset();
-        puffettes.clear();
-        triggered_puffettes.clear();
-        assert(is_dead());
+        proto = boost::blank();
     }
 
-    std::unique_ptr<NGHolder> holder;
-    std::unique_ptr<raw_dfa> rdfa;
-    std::unique_ptr<raw_som_dfa> haig;
-    std::vector<raw_puff> puffettes;
-    std::vector<raw_puff> triggered_puffettes;
+    // Convenience accessor functions.
 
-    /** Once the outfix has been built into an engine, this will point to it. */
-    NFA *nfa = nullptr;
+    NGHolder *holder() {
+        auto *up = boost::get<std::unique_ptr<NGHolder>>(&proto);
+        return up ? up->get() : nullptr;
+    }
+    raw_dfa *rdfa() {
+        auto *up = boost::get<std::unique_ptr<raw_dfa>>(&proto);
+        return up ? up->get() : nullptr;
+    }
+    raw_som_dfa *haig() {
+        auto *up = boost::get<std::unique_ptr<raw_som_dfa>>(&proto);
+        return up ? up->get() : nullptr;
+    }
+    MpvProto *mpv() {
+        return boost::get<MpvProto>(&proto);
+    }
+
+    // Convenience const accessor functions.
+
+    const NGHolder *holder() const {
+        auto *up = boost::get<std::unique_ptr<NGHolder>>(&proto);
+        return up ? up->get() : nullptr;
+    }
+    const raw_dfa *rdfa() const {
+        auto *up = boost::get<std::unique_ptr<raw_dfa>>(&proto);
+        return up ? up->get() : nullptr;
+    }
+    const raw_som_dfa *haig() const {
+        auto *up = boost::get<std::unique_ptr<raw_som_dfa>>(&proto);
+        return up ? up->get() : nullptr;
+    }
+    const MpvProto *mpv() const {
+        return boost::get<MpvProto>(&proto);
+    }
+
+    /**
+     * \brief Variant wrapping the various engine types. If this is
+     * boost::blank, it means that this outfix is unused (dead).
+     */
+    boost::variant<
+        boost::blank,
+        std::unique_ptr<NGHolder>,
+        std::unique_ptr<raw_dfa>,
+        std::unique_ptr<raw_som_dfa>,
+        MpvProto> proto = boost::blank();
 
     RevAccInfo rev_info;
     u32 maxBAWidth = 0; //!< max bi-anchored width
     depth minWidth = depth::infinity();
     depth maxWidth = 0;
     u64a maxOffset = 0;
-    bool chained = false;
     bool in_sbmatcher = false; //!< handled by small-block matcher.
 
 private:
@@ -389,8 +436,6 @@ public:
 
     std::unique_ptr<RoseDedupeAux> generateDedupeAux() const override;
 
-    bool hasEodSideLink() const;
-
     // Find the maximum bound on the edges to this vertex's successors.
     u32 calcSuccMaxBound(RoseVertex u) const;
 
@@ -415,7 +460,6 @@ public:
 
     // Is the Rose anchored?
     bool hasNoFloatingRoots() const;
-    bool hasDirectReports() const;
 
     RoseVertex cloneVertex(RoseVertex v);
 
@@ -440,8 +484,7 @@ public:
 
     bool isDirectReport(u32 id) const;
     bool isDelayed(u32 id) const;
-    bool hasDirectFinalId(u32 id) const;
-    bool hasDirectFinalId(RoseVertex v) const;
+
     bool hasFinalId(u32 id) const;
 
     bool isAnchored(RoseVertex v) const; /* true iff has literal in anchored
@@ -494,11 +537,8 @@ public:
     u32 group_weak_end;
     u32 group_end;
 
-    std::map<CharReach, std::set<RoseVertex> > side_squash_roles;
-
     u32 anchored_base_id;
 
-    u32 nonbenefits_base_id;
     u32 ematcher_region_size; /**< number of bytes the eod table runs over */
 
     /** \brief Mapping from anchored literal ID to the original literal suffix
@@ -519,16 +559,10 @@ public:
      * null again). */
     std::unique_ptr<OutfixInfo> mpv_outfix = nullptr;
 
-    bool floating_direct_report;
-
     u32 eod_event_literal_id; // ID of EOD event literal, or MO_INVALID_IDX.
 
     u32 max_rose_anchored_floating_overlap;
 
-    /** \brief Flattened list of report IDs for multi-direct reports, indexed
-     * by MDR final_id. */
-    std::vector<ReportID> mdr_reports;
-
     QueueIndexFactory qif;
     ReportManager &rm;
     SomSlotManager &ssm;
@@ -544,6 +578,9 @@ bool hasAnchHistorySucc(const RoseGraph &g, RoseVertex v);
 bool hasLastByteHistorySucc(const RoseGraph &g, RoseVertex v);
 
 size_t maxOverlap(const rose_literal_id &a, const rose_literal_id &b);
+ue2_literal findNonOverlappingTail(const std::set<ue2_literal> &lits,
+                                   const ue2_literal &s);
+
 void setReportId(NGHolder &g, ReportID id);
 
 #ifndef NDEBUG
@@ -558,13 +595,6 @@ u64a findMaxOffset(const std::set<ReportID> &reports, const ReportManager &rm);
 void normaliseLiteralMask(const ue2_literal &s, std::vector<u8> &msk,
                           std::vector<u8> &cmp);
 
-void fillHamsterLiteralList(const RoseBuildImpl &tbi, rose_literal_table table,
-                            std::vector<hwlmLiteral> *hl);
-
-// Find the minimum depth in hops of each role. Note that a role may be
-// accessible from both the root and the anchored root.
-std::map<RoseVertex, u32> findDepths(const RoseBuildImpl &build);
-
 #ifndef NDEBUG
 bool canImplementGraphs(const RoseBuildImpl &tbi);
 #endif
diff --git a/src/rose/rose_build_lookaround.cpp b/src/rose/rose_build_lookaround.cpp
index 02843fee..54c01e08 100644
--- a/src/rose/rose_build_lookaround.cpp
+++ b/src/rose/rose_build_lookaround.cpp
@@ -582,6 +582,30 @@ bool getTransientPrefixReach(const NGHolder &g, u32 lag,
     return true;
 }
 
+static
+void normaliseLeftfix(map<s32, CharReach> &look) {
+    // We can erase entries where the reach is "all characters", except for the
+    // very first one -- this might be required to establish a minimum bound on
+    // the literal's match offset.
+
+    // TODO: It would be cleaner to use a literal program instruction to check
+    // the minimum bound explicitly.
+
+    if (look.empty()) {
+        return;
+    }
+
+    const auto earliest = begin(look)->first;
+
+    vector<s32> dead;
+    for (const auto &m : look) {
+        if (m.second.all() && m.first != earliest) {
+            dead.push_back(m.first);
+        }
+    }
+    erase_all(&look, dead);
+}
+
 bool makeLeftfixLookaround(const RoseBuildImpl &build, const RoseVertex v,
                            vector<LookEntry> &lookaround) {
     lookaround.clear();
@@ -606,6 +630,7 @@ bool makeLeftfixLookaround(const RoseBuildImpl &build, const RoseVertex v,
     }
 
     trimLiterals(build, v, look);
+    normaliseLeftfix(look);
 
     if (look.size() > MAX_LOOKAROUND_ENTRIES) {
         DEBUG_PRINTF("lookaround too big (%zu entries)\n", look.size());
diff --git a/src/rose/rose_build_matchers.cpp b/src/rose/rose_build_matchers.cpp
new file mode 100644
index 00000000..83c49556
--- /dev/null
+++ b/src/rose/rose_build_matchers.cpp
@@ -0,0 +1,662 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * \file
+ * \brief Rose build: code for constructing literal tables.
+ */
+
+#include "rose_build_matchers.h"
+
+#include "rose_build_impl.h"
+#include "rose_build_width.h"
+#include "hwlm/hwlm_build.h"
+#include "hwlm/hwlm_literal.h"
+#include "nfa/castlecompile.h"
+#include "util/charreach_util.h"
+#include "util/compile_context.h"
+#include "util/compile_error.h"
+#include "util/dump_charclass.h"
+#include "util/report.h"
+#include "util/report_manager.h"
+#include "ue2common.h"
+
+#include <iomanip>
+#include <sstream>
+
+#include <boost/range/adaptor/map.hpp>
+
+using namespace std;
+using boost::adaptors::map_values;
+
+namespace ue2 {
+
+#ifdef DEBUG
+static UNUSED
+string dumpMask(const vector<u8> &v) {
+    ostringstream oss;
+    for (u8 e : v) {
+        oss << setfill('0') << setw(2) << hex << (unsigned int)e;
+    }
+    return oss.str();
+}
+#endif
+
+static
+bool maskFromLeftGraph(const LeftEngInfo &left, vector<u8> &msk,
+                       vector<u8> &cmp) {
+    const u32 lag = left.lag;
+    const ReportID report = left.leftfix_report;
+
+    DEBUG_PRINTF("leftfix with lag %u, report %u\n", lag, report);
+
+    assert(left.graph);
+    const NGHolder &h = *left.graph;
+    assert(in_degree(h.acceptEod, h) == 1); // no eod reports
+
+    // Start with the set of reporter vertices for this leftfix.
+    set<NFAVertex> curr;
+    for (auto u : inv_adjacent_vertices_range(h.accept, h)) {
+        if (contains(h[u].reports, report)) {
+            curr.insert(u);
+        }
+    }
+    assert(!curr.empty());
+
+    size_t i = HWLM_MASKLEN - lag - 1;
+    do {
+        if (curr.empty() || contains(curr, h.start)
+            || contains(curr, h.startDs)) {
+            DEBUG_PRINTF("end of the road\n");
+            break;
+        }
+
+        set<NFAVertex> next;
+        CharReach cr;
+        for (NFAVertex v : curr) {
+            const auto &v_cr = h[v].char_reach;
+            DEBUG_PRINTF("vertex %u, reach %s\n", h[v].index,
+                         describeClass(v_cr).c_str());
+            cr |= v_cr;
+            insert(&next, inv_adjacent_vertices(v, h));
+        }
+        make_and_cmp_mask(cr, &msk.at(i), &cmp.at(i));
+        DEBUG_PRINTF("%zu: reach=%s, msk=%u, cmp=%u\n", i,
+                     describeClass(cr).c_str(), msk[i], cmp[i]);
+        curr.swap(next);
+    } while (i-- > 0);
+
+    return true;
+}
+
+static
+bool maskFromLeftCastle(const LeftEngInfo &left, vector<u8> &msk,
+                        vector<u8> &cmp) {
+    const u32 lag = left.lag;
+    const ReportID report = left.leftfix_report;
+
+    DEBUG_PRINTF("leftfix with lag %u, report %u\n", lag, report);
+
+    assert(left.castle);
+    const CastleProto &c = *left.castle;
+
+    depth min_width(depth::infinity());
+    for (const PureRepeat &repeat : c.repeats | map_values) {
+        if (contains(repeat.reports, report)) {
+            min_width = min(min_width, repeat.bounds.min);
+        }
+    }
+
+    DEBUG_PRINTF("castle min width for this report is %s\n",
+                 min_width.str().c_str());
+
+    if (!min_width.is_finite() || min_width == depth(0)) {
+        DEBUG_PRINTF("bad min width\n");
+        return false;
+    }
+
+    u32 len = min_width;
+    u32 end = HWLM_MASKLEN - lag;
+    for (u32 i = end; i > end - min(end, len); i--) {
+        make_and_cmp_mask(c.reach(), &msk.at(i - 1), &cmp.at(i - 1));
+    }
+
+    return true;
+}
+
+static
+bool maskFromLeft(const LeftEngInfo &left, vector<u8> &msk, vector<u8> &cmp) {
+    if (left.lag >= HWLM_MASKLEN) {
+        DEBUG_PRINTF("too much lag\n");
+        return false;
+    }
+
+    if (left.graph) {
+        return maskFromLeftGraph(left, msk, cmp);
+    } else if (left.castle) {
+        return maskFromLeftCastle(left, msk, cmp);
+    }
+
+    return false;
+}
+
+static
+bool maskFromPreds(const RoseBuildImpl &build, const rose_literal_id &id,
+                   const RoseVertex v, vector<u8> &msk, vector<u8> &cmp) {
+    const RoseGraph &g = build.g;
+
+    // For right now, wuss out and only handle cases with one pred.
+    if (in_degree(v, g) != 1) {
+        return false;
+    }
+
+    // Root successors have no literal before them.
+    if (build.isRootSuccessor(v)) {
+        return false;
+    }
+
+    // If we have a single predecessor with a short bound, we may be able to
+    // fill out a mask with the trailing bytes of the previous literal. This
+    // allows us to improve literals like the 'bar' in 'fo.bar'.
+
+    RoseEdge e = *(in_edges(v, g).first);
+    u32 bound = g[e].maxBound;
+    if (bound != g[e].minBound || bound >= HWLM_MASKLEN) {
+        return false;
+    }
+
+    bound += id.s.length();
+    if (bound >= HWLM_MASKLEN) {
+        return false;
+    }
+
+    DEBUG_PRINTF("bound %u\n", bound);
+
+    RoseVertex u = source(e, g);
+    if (g[u].literals.size() != 1) {
+        DEBUG_PRINTF("u has %zu literals\n", g[u].literals.size());
+        return false;
+    }
+
+    u32 u_lit_id = *(g[u].literals.begin());
+    const rose_literal_id &u_id = build.literals.right.at(u_lit_id);
+    DEBUG_PRINTF("u has lit: %s\n", escapeString(u_id.s).c_str());
+
+    // Number of characters to take from the back of u's literal.
+    size_t u_len = u_id.s.length();
+    size_t u_sublen = min(u_len, (size_t)HWLM_MASKLEN - bound);
+
+    size_t i = HWLM_MASKLEN - (bound + u_sublen);
+
+    ue2_literal::const_iterator it, ite;
+    for (it = u_id.s.begin() + (u_len - u_sublen), ite = u_id.s.end();
+            it != ite; ++it) {
+        make_and_cmp_mask(*it, &msk.at(i), &cmp.at(i));
+        ++i;
+    }
+
+    return true;
+}
+
+static
+bool findHamsterMask(const RoseBuildImpl &build, const rose_literal_id &id,
+                     const rose_literal_info &info, const RoseVertex v,
+                     vector<u8> &msk, vector<u8> &cmp) {
+    // Start with zero masks.
+    msk.assign(HWLM_MASKLEN, 0);
+    cmp.assign(HWLM_MASKLEN, 0);
+
+    // Masks can come from literal benefits (for mixed-case literals).
+    if (info.requires_benefits) {
+        assert(mixed_sensitivity(id.s));
+
+        size_t j = 0;
+        for (ue2_literal::const_reverse_iterator it = id.s.rbegin(),
+                                                 ite = id.s.rend();
+             it != ite && j < HWLM_MASKLEN; ++it, ++j) {
+            size_t offset = HWLM_MASKLEN - j - 1;
+            const CharReach &cr = *it;
+            make_and_cmp_mask(cr, &msk[offset], &cmp[offset]);
+        }
+        return true;
+    }
+
+    const LeftEngInfo &left = build.g[v].left;
+    if (left && left.lag < HWLM_MASKLEN) {
+        if (maskFromLeft(left, msk, cmp)) {
+            DEBUG_PRINTF("mask from a leftfix!\n");
+            return true;
+        }
+    }
+
+    if (id.s.length() < HWLM_MASKLEN) {
+        if (maskFromPreds(build, id, v, msk, cmp)) {
+            DEBUG_PRINTF("mask from preds!\n");
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static
+bool hamsterMaskCombine(vector<u8> &msk, vector<u8> &cmp,
+                        const vector<u8> &v_msk, const vector<u8> &v_cmp) {
+    assert(msk.size() == HWLM_MASKLEN && cmp.size() == HWLM_MASKLEN);
+    assert(v_msk.size() == HWLM_MASKLEN && v_cmp.size() == HWLM_MASKLEN);
+
+    u8 all_masks = 0;
+
+    for (size_t i = 0; i < HWLM_MASKLEN; i++) {
+        u8 filter = ~(cmp[i] ^ v_cmp[i]);
+        msk[i] &= v_msk[i];
+        msk[i] &= filter;
+        cmp[i] &= filter;
+
+        all_masks |= msk[i];
+    }
+
+    // Return false if we have no bits on in any mask elements.
+    return all_masks != 0;
+}
+
+static
+bool findHamsterMask(const RoseBuildImpl &build, const rose_literal_id &id,
+                     const rose_literal_info &info,
+                     vector<u8> &msk, vector<u8> &cmp) {
+    if (!build.cc.grey.roseHamsterMasks) {
+        return false;
+    }
+
+    if (!info.delayed_ids.empty()) {
+        // Not safe to add masks to delayed literals at this late stage.
+        return false;
+    }
+
+    size_t num = 0;
+    vector<u8> v_msk, v_cmp;
+
+    for (RoseVertex v : info.vertices) {
+        if (!findHamsterMask(build, id, info, v, v_msk, v_cmp)) {
+            DEBUG_PRINTF("no mask\n");
+            return false;
+        }
+
+        if (!num++) {
+            // First (or only) vertex, this becomes the mask/cmp pair.
+            msk = v_msk;
+            cmp = v_cmp;
+        } else {
+            // Multiple vertices with potentially different masks. We combine
+            // them into an 'advisory' mask.
+            if (!hamsterMaskCombine(msk, cmp, v_msk, v_cmp)) {
+                DEBUG_PRINTF("mask went to zero\n");
+                return false;
+            }
+        }
+    }
+
+    normaliseLiteralMask(id.s, msk, cmp);
+
+    if (msk.empty()) {
+        DEBUG_PRINTF("no mask\n");
+        return false;
+    }
+
+    DEBUG_PRINTF("msk=%s, cmp=%s\n", dumpMask(msk).c_str(),
+                 dumpMask(cmp).c_str());
+    return true;
+}
+
+static
+bool isDirectHighlander(const RoseBuildImpl &build, const u32 id,
+                        const rose_literal_info &info) {
+    if (!build.isDirectReport(id)) {
+        return false;
+    }
+
+    auto is_simple_exhaustible = [&build](ReportID id) {
+        const Report &report = build.rm.getReport(id);
+        return isSimpleExhaustible(report);
+    };
+
+    assert(!info.vertices.empty());
+    for (const auto &v : info.vertices) {
+        const auto &reports = build.g[v].reports;
+        assert(!reports.empty());
+        if (!all_of(begin(reports), end(reports),
+                    is_simple_exhaustible)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// Called by isNoRunsLiteral below.
+static
+bool isNoRunsVertex(const RoseBuildImpl &build, NFAVertex u) {
+    const RoseGraph &g = build.g;
+    if (!g[u].isBoring()) {
+        DEBUG_PRINTF("u=%zu is not boring\n", g[u].idx);
+        return false;
+    }
+
+    if (!g[u].reports.empty()) {
+        DEBUG_PRINTF("u=%zu has accept\n", g[u].idx);
+        return false;
+    }
+
+    /* TODO: handle non-root roles as well. It can't be that difficult... */
+
+    if (!in_degree_equal_to(u, g, 1)) {
+        DEBUG_PRINTF("u=%zu is not a root role\n", g[u].idx);
+        return false;
+    }
+
+    RoseEdge e;
+    bool exists;
+    tie(e, exists) = edge_by_target(build.root, u, g);
+
+    if (!exists) {
+        DEBUG_PRINTF("u=%zu is not a root role\n", g[u].idx);
+        return false;
+    }
+
+    if (g[e].minBound != 0 || g[e].maxBound != ROSE_BOUND_INF) {
+        DEBUG_PRINTF("u=%zu has bounds from root\n", g[u].idx);
+        return false;
+    }
+
+    for (const auto &oe : out_edges_range(u, g)) {
+        RoseVertex v = target(oe, g);
+        if (g[oe].maxBound != ROSE_BOUND_INF) {
+            DEBUG_PRINTF("edge (%zu,%zu) has max bound\n", g[u].idx,
+                    g[target(oe, g)].idx);
+            return false;
+        }
+        if (g[v].left) {
+            DEBUG_PRINTF("v=%zu has rose prefix\n", g[v].idx);
+            return false;
+        }
+    }
+    return true;
+}
+
+static
+bool isNoRunsLiteral(const RoseBuildImpl &build, const u32 id,
+                     const rose_literal_info &info) {
+    DEBUG_PRINTF("lit id %u\n", id);
+
+    if (info.requires_benefits) {
+        DEBUG_PRINTF("requires benefits\n"); // which would need confirm
+        return false;
+    }
+
+    if (isDirectHighlander(build, id, info)) {
+        DEBUG_PRINTF("highlander direct report\n");
+        return true;
+    }
+
+    // Undelayed vertices.
+    for (RoseVertex v : info.vertices) {
+        if (!isNoRunsVertex(build, v)) {
+            return false;
+        }
+    }
+
+    // Delayed vertices.
+    for (u32 d : info.delayed_ids) {
+        assert(d < build.literal_info.size());
+        const rose_literal_info &delayed_info = build.literal_info.at(d);
+        assert(delayed_info.undelayed_id == id);
+        for (RoseVertex v : delayed_info.vertices) {
+            if (!isNoRunsVertex(build, v)) {
+                return false;
+            }
+        }
+    }
+
+    DEBUG_PRINTF("is no-runs literal\n");
+    return true;
+}
+
+vector<hwlmLiteral> fillHamsterLiteralList(const RoseBuildImpl &build,
+                                           rose_literal_table table) {
+    vector<hwlmLiteral> lits;
+
+    for (const auto &e : build.literals.right) {
+        const u32 id = e.first;
+        if (!build.hasFinalId(id)) {
+            continue;
+        }
+
+        if (e.second.delay) {
+            continue; /* delay id's are virtual-ish */
+        }
+
+        if (e.second.table != table) {
+            continue; /* wrong table */
+        }
+
+        assert(id < build.literal_info.size());
+        const rose_literal_info &info = build.literal_info[id];
+        u32 final_id = info.final_id;
+        rose_group groups = info.group_mask;
+        /* Note: requires_benefits are handled in the literal entries */
+        const ue2_literal &lit = e.second.s;
+
+        DEBUG_PRINTF("lit='%s'\n", escapeString(lit).c_str());
+
+        vector<u8> msk = e.second.msk; // copy
+        vector<u8> cmp = e.second.cmp; // copy
+
+        if (msk.empty()) {
+            // Try and pick up an advisory mask.
+            if (!findHamsterMask(build, e.second, info, msk, cmp)) {
+                msk.clear(); cmp.clear();
+            } else {
+                DEBUG_PRINTF("picked up late mask %zu\n", msk.size());
+            }
+        }
+
+        bool noruns = isNoRunsLiteral(build, id, info);
+
+        if (info.requires_explode) {
+            DEBUG_PRINTF("exploding lit\n");
+            const vector<u8> empty_msk; // msk/cmp will be empty
+            case_iter cit = caseIterateBegin(lit);
+            case_iter cite = caseIterateEnd();
+            for (; cit != cite; ++cit) {
+                DEBUG_PRINTF("id=%u, s='%s', nocase=%d, noruns=%d msk=%s, "
+                             "cmp=%s (exploded)\n",
+                             final_id, escapeString(lit.get_string()).c_str(),
+                             0, noruns, dumpMask(msk).c_str(),
+                             dumpMask(cmp).c_str());
+                lits.emplace_back(*cit, false, noruns, final_id, groups,
+                                  empty_msk, empty_msk);
+            }
+        } else {
+            const std::string &s = lit.get_string();
+            const bool nocase = lit.any_nocase();
+
+            DEBUG_PRINTF("id=%u, s='%s', nocase=%d, noruns=%d, msk=%s, "
+                         "cmp=%s\n",
+                         final_id, escapeString(s).c_str(), (int)nocase, noruns,
+                         dumpMask(msk).c_str(), dumpMask(cmp).c_str());
+
+            if (!maskIsConsistent(s, nocase, msk, cmp)) {
+                DEBUG_PRINTF("msk/cmp for literal can't match, skipping\n");
+                continue;
+            }
+
+            lits.emplace_back(lit.get_string(), lit.any_nocase(), noruns,
+                              final_id, groups, msk, cmp);
+        }
+    }
+
+    return lits;
+}
+
+aligned_unique_ptr<HWLM> buildFloatingMatcher(const RoseBuildImpl &build,
+                                              size_t *fsize,
+                                              size_t *historyRequired,
+                                              size_t *streamStateRequired) {
+    *fsize = 0;
+
+    auto fl = fillHamsterLiteralList(build, ROSE_FLOATING);
+    if (fl.empty()) {
+        DEBUG_PRINTF("empty floating matcher\n");
+        return nullptr;
+    }
+
+    hwlmStreamingControl ctl;
+    hwlmStreamingControl *ctlp;
+    if (build.cc.streaming) {
+        ctl.history_max = build.cc.grey.maxHistoryAvailable;
+        ctl.history_min = MAX(*historyRequired,
+                              build.cc.grey.minHistoryAvailable);
+        DEBUG_PRINTF("streaming control, history max=%zu, min=%zu\n",
+                     ctl.history_max, ctl.history_min);
+        ctlp = &ctl;
+    } else {
+        ctlp = nullptr; // Null for non-streaming.
+    }
+
+    aligned_unique_ptr<HWLM> ftable =
+        hwlmBuild(fl, ctlp, false, build.cc, build.getInitialGroups());
+    if (!ftable) {
+        throw CompileError("Unable to generate bytecode.");
+    }
+
+    if (build.cc.streaming) {
+        DEBUG_PRINTF("literal_history_required=%zu\n",
+                ctl.literal_history_required);
+        DEBUG_PRINTF("literal_stream_state_required=%zu\n",
+                ctl.literal_stream_state_required);
+        assert(ctl.literal_history_required <=
+               build.cc.grey.maxHistoryAvailable);
+        *historyRequired = max(*historyRequired,
+                ctl.literal_history_required);
+        *streamStateRequired = ctl.literal_stream_state_required;
+    }
+
+    *fsize = hwlmSize(ftable.get());
+    assert(*fsize);
+    DEBUG_PRINTF("built floating literal table size %zu bytes\n", *fsize);
+    return ftable;
+}
+
+aligned_unique_ptr<HWLM> buildSmallBlockMatcher(const RoseBuildImpl &build,
+                                                size_t *sbsize) {
+    *sbsize = 0;
+
+    if (build.cc.streaming) {
+        DEBUG_PRINTF("streaming mode\n");
+        return nullptr;
+    }
+
+    u32 float_min = findMinWidth(build, ROSE_FLOATING);
+    if (float_min > ROSE_SMALL_BLOCK_LEN) {
+        DEBUG_PRINTF("floating table has large min width %u, fail\n",
+                     float_min);
+        return nullptr;
+    }
+
+    auto lits = fillHamsterLiteralList(build, ROSE_FLOATING);
+    if (lits.empty()) {
+        DEBUG_PRINTF("no floating table\n");
+        return nullptr;
+    } else if (lits.size() == 1) {
+        DEBUG_PRINTF("single floating literal, noodle will be fast enough\n");
+        return nullptr;
+    }
+
+    auto anchored_lits =
+        fillHamsterLiteralList(build, ROSE_ANCHORED_SMALL_BLOCK);
+    if (anchored_lits.empty()) {
+        DEBUG_PRINTF("no small-block anchored literals\n");
+        return nullptr;
+    }
+
+    lits.insert(lits.end(), anchored_lits.begin(), anchored_lits.end());
+
+    // Remove literals that are longer than our small block length, as they can
+    // never match. TODO: improve by removing literals that have a min match
+    // offset greater than ROSE_SMALL_BLOCK_LEN, which will catch anchored cases
+    // with preceding dots that put them over the limit.
+    auto longer_than_limit = [](const hwlmLiteral &lit) {
+        return lit.s.length() > ROSE_SMALL_BLOCK_LEN;
+    };
+    lits.erase(remove_if(lits.begin(), lits.end(), longer_than_limit),
+               lits.end());
+
+    if (lits.empty()) {
+        DEBUG_PRINTF("no literals shorter than small block len\n");
+        return nullptr;
+    }
+
+    aligned_unique_ptr<HWLM> hwlm =
+        hwlmBuild(lits, nullptr, true, build.cc, build.getInitialGroups());
+    if (!hwlm) {
+        throw CompileError("Unable to generate bytecode.");
+    }
+
+    *sbsize = hwlmSize(hwlm.get());
+    assert(*sbsize);
+    DEBUG_PRINTF("built small block literal table size %zu bytes\n", *sbsize);
+    return hwlm;
+}
+
+aligned_unique_ptr<HWLM> buildEodAnchoredMatcher(const RoseBuildImpl &build,
+                                                 size_t *esize) {
+    *esize = 0;
+
+    auto el = fillHamsterLiteralList(build, ROSE_EOD_ANCHORED);
+
+    if (el.empty()) {
+        DEBUG_PRINTF("no eod anchored literals\n");
+        assert(!build.ematcher_region_size);
+        return nullptr;
+    }
+
+    assert(build.ematcher_region_size);
+
+    hwlmStreamingControl *ctlp = nullptr; // not a streaming case
+    aligned_unique_ptr<HWLM> etable =
+        hwlmBuild(el, ctlp, true, build.cc, build.getInitialGroups());
+    if (!etable) {
+        throw CompileError("Unable to generate bytecode.");
+    }
+
+    *esize = hwlmSize(etable.get());
+    assert(*esize);
+    DEBUG_PRINTF("built eod-anchored literal table size %zu bytes\n", *esize);
+    return etable;
+}
+
+} // namespace ue2
diff --git a/src/rose/rose_build_matchers.h b/src/rose/rose_build_matchers.h
new file mode 100644
index 00000000..9781f514
--- /dev/null
+++ b/src/rose/rose_build_matchers.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * \file
+ * \brief Rose build: code for constructing literal tables.
+ */
+
+#ifndef ROSE_BUILD_MATCHERS_H
+#define ROSE_BUILD_MATCHERS_H
+
+#include "rose_build_impl.h"
+
+#include <vector>
+
+struct HWLM;
+
+namespace ue2 {
+
+struct hwlmLiteral;
+
+std::vector<hwlmLiteral> fillHamsterLiteralList(const RoseBuildImpl &build,
+                                                rose_literal_table table);
+
+aligned_unique_ptr<HWLM> buildFloatingMatcher(const RoseBuildImpl &build,
+                                              size_t *fsize,
+                                              size_t *historyRequired,
+                                              size_t *streamStateRequired);
+
+aligned_unique_ptr<HWLM> buildSmallBlockMatcher(const RoseBuildImpl &build,
+                                                size_t *sbsize);
+
+aligned_unique_ptr<HWLM> buildEodAnchoredMatcher(const RoseBuildImpl &build,
+                                                 size_t *esize);
+
+} // namespace ue2
+
+#endif // ROSE_BUILD_MATCHERS_H
diff --git a/src/rose/rose_build_merge.cpp b/src/rose/rose_build_merge.cpp
index 4c55a41f..a10bc86e 100644
--- a/src/rose/rose_build_merge.cpp
+++ b/src/rose/rose_build_merge.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -93,6 +93,7 @@ static const size_t SMALL_MERGE_MAX_VERTICES_BLOCK = 64;
 static const size_t SMALL_ROSE_THRESHOLD_STREAM = 32;
 static const size_t SMALL_ROSE_THRESHOLD_BLOCK = 10;
 static const size_t MERGE_GROUP_SIZE_MAX = 200;
+static const size_t MERGE_CASTLE_GROUP_SIZE_MAX = 1000;
 
 /** \brief Max number of DFAs (McClellan, Haig) to pairwise merge together. */
 static const size_t DFA_CHUNK_SIZE_MAX = 200;
@@ -104,6 +105,10 @@ static const size_t DFA_MERGE_MAX_STATES = 8000;
  * merging with other graphs. */
 static const size_t LARGE_LBR_MIN_VERTICES = 32;
 
+/** \brief In block mode, merge two prefixes even if they don't have identical
+ * literal sets if they have fewer than this many states and the merged graph
+ * is also small. */
+static constexpr size_t MAX_BLOCK_PREFIX_MERGE_VERTICES = 32;
 
 static
 size_t small_merge_max_vertices(const CompileContext &cc) {
@@ -799,47 +804,69 @@ static void chunkBouquets(const Bouquet<EngineRef> &in,
     }
 }
 
+static
+bool stringsCanFinishAtSameSpot(const ue2_literal &u,
+                                ue2_literal::const_iterator v_b,
+                                ue2_literal::const_iterator v_e) {
+    ue2_literal::const_iterator u_e = u.end();
+    ue2_literal::const_iterator u_b = u.begin();
+
+    while (u_e != u_b && v_e != v_b) {
+        --u_e;
+        --v_e;
+
+        if (!overlaps(*u_e, *v_e)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 /**
- * Prefix analysis: For lit1 with delay1 and lit2 with delay2, let L be the
- * length of the largest suffix of lit1 that is a prefix of lit2. A merge is
- * bad if L - delay1 > len(lit2) - delay2.
+ * Check that if after u has been seen, that it is impossible for the arrival of
+ * v to require the inspection of an engine earlier than u did.
  *
- * OR if we would have to check 2 literals of differing lags at the same
- * point.
+ * Let delta be the earliest that v can be seen after u (may be zero)
+ *
+ * ie, we require u_loc - ulag <= v_loc - vlag (v_loc = u_loc + delta)
+ * ==> - ulag <= delta - vlag
+ * ==> vlag - ulag <= delta
  */
 static
 bool checkPrefix(const rose_literal_id &ul, const u32 ulag,
                  const rose_literal_id &vl, const u32 vlag) {
-    DEBUG_PRINTF("%s %s\n", escapeString(ul.s).c_str(),
-                 escapeString(vl.s).c_str());
-    if (ulag != vlag && (vl.delay || ul.delay || isSuffix(ul.s, vl.s))) {
-        /* rose literals should not be delayed anyway */
+    DEBUG_PRINTF("'%s'-%u '%s'-%u\n", escapeString(ul.s).c_str(), ulag,
+                 escapeString(vl.s).c_str(), vlag);
+
+    if (vl.delay || ul.delay) {
+        /* engine related literals should not be delayed anyway */
         return false;
     }
 
-    // Note that maxOverlap also picks up infixes.
-    size_t overlap = maxOverlap(ul, vl);
-    if (overlap < ulag) {
-        return true; /* avoiding underflow */
+    if (ulag >= vlag) {
+        assert(maxOverlap(ul, vl) <= vl.elength() - vlag + ulag);
+        return true;
     }
-    return overlap - ulag <= vl.elength() - vlag;
+
+    size_t min_allowed_delta = vlag - ulag;
+    DEBUG_PRINTF("min allow distace %zu\n", min_allowed_delta);
+
+    for (size_t i = 0; i < min_allowed_delta; i++) {
+        if (stringsCanFinishAtSameSpot(ul.s, vl.s.begin(), vl.s.end() - i)) {
+            DEBUG_PRINTF("v can follow u at a (too close) distance of %zu\n", i);
+            return false;
+        }
+    }
+
+    DEBUG_PRINTF("OK\n");
+    return true;
 }
 
-bool mergeableRoseVertices(const RoseBuildImpl &tbi, RoseVertex u,
-                           RoseVertex v) {
-    assert(u != v);
-
-    const auto &ulits = tbi.g[u].literals;
-    const auto &vlits = tbi.g[v].literals;
-
-    // We cannot merge roses that prefix literals in different tables.
-    if (tbi.literals.right.at(*ulits.begin()).table !=
-            tbi.literals.right.at(*vlits.begin()).table) {
-        DEBUG_PRINTF("literals in different tables\n");
-        return false;
-    }
-
-    const left_id u_left(tbi.g[u].left), v_left(tbi.g[v].left);
+static
+bool hasSameEngineType(const RoseVertexProps &u_prop,
+                       const RoseVertexProps &v_prop) {
+    const left_id u_left(u_prop.left), v_left(v_prop.left);
 
     if (u_left.haig() || v_left.haig()) {
         if (u_left.graph() != v_left.graph()) {
@@ -859,14 +886,157 @@ bool mergeableRoseVertices(const RoseBuildImpl &tbi, RoseVertex u,
         }
     }
 
-    // UE-1675: in block mode, we want to be a little more selective -- only
-    // merge prefix roses when the literal sets are the same.
-    if (!tbi.cc.streaming && tbi.isRootSuccessor(u)) {
-        assert(tbi.isRootSuccessor(v));
-        if (ulits != vlits) {
-            DEBUG_PRINTF("literals aren't identical (block mode prefix)\n");
-            return false;
+    return true;
+}
+
+static
+bool compatibleLiteralsForMerge(
+                     const vector<pair<const rose_literal_id *, u32>> &ulits,
+                     const vector<pair<const rose_literal_id *, u32>> &vlits) {
+    assert(!ulits.empty());
+    assert(!vlits.empty());
+
+    // We cannot merge engines that prefix literals in different tables.
+    if (ulits[0].first->table != vlits[0].first->table) {
+        DEBUG_PRINTF("literals in different tables\n");
+        return false;
+    }
+
+    /* An engine requires that all accesses to it are ordered by offsets. (ie,
+       we can not check an engine's state at offset Y, if we have already
+       checked its status at offset X and X > Y). If we can not establish that
+       the literals used for triggering will statisfy this property, then it is
+       not safe to merge the engine. */
+    for (const auto &ue : ulits) {
+        const rose_literal_id &ul = *ue.first;
+        u32 ulag = ue.second;
+
+        if (ul.delay) {
+            return false; // We don't handle delayed cases yet.
         }
+
+        for (const auto &ve : vlits) {
+            const rose_literal_id &vl = *ve.first;
+            u32 vlag = ve.second;
+
+            if (vl.delay) {
+                return false; // We don't handle delayed cases yet.
+            }
+
+            if (!checkPrefix(ul, ulag, vl, vlag)
+                || !checkPrefix(vl, vlag, ul, ulag)) {
+                DEBUG_PRINTF("prefix check failed\n");
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+/**
+ * True if this graph has few enough accel states to be implemented as an NFA
+ * with all of those states actually becoming accel schemes.
+ */
+static
+bool isAccelerableLeftfix(const RoseBuildImpl &build, const NGHolder &g) {
+    u32 num = countAccelStates(g, &build.rm, build.cc);
+    DEBUG_PRINTF("graph with %zu vertices has %u accel states\n",
+                  num_vertices(g), num);
+    return num <= NFA_MAX_ACCEL_STATES;
+}
+
+/**
+ * In block mode, we want to be a little more selective, We will only merge
+ * prefix engines when the literal sets are the same, or if the merged graph
+ * has only grown by a small amount.
+ */
+static
+bool safeBlockModeMerge(const RoseBuildImpl &build, RoseVertex u,
+                        RoseVertex v) {
+    assert(!build.cc.streaming);
+    assert(build.isRootSuccessor(u) == build.isRootSuccessor(v));
+
+    // Always merge infixes if we can (subject to the other criteria in
+    // mergeableRoseVertices).
+    if (!build.isRootSuccessor(u)) {
+        return true;
+    }
+
+    const RoseGraph &g = build.g;
+
+    // Merge prefixes with identical literal sets (as we'd have to run them
+    // both when we see those literals anyway).
+    if (g[u].literals == g[v].literals) {
+        return true;
+    }
+
+    // The rest of this function only deals with the case when both vertices
+    // have graph leftfixes.
+    if (!g[u].left.graph || !g[v].left.graph) {
+        return false;
+    }
+
+    const size_t u_count = num_vertices(*g[u].left.graph);
+    const size_t v_count = num_vertices(*g[v].left.graph);
+    DEBUG_PRINTF("u prefix has %zu vertices, v prefix has %zu vertices\n",
+                 u_count, v_count);
+    if (u_count > MAX_BLOCK_PREFIX_MERGE_VERTICES ||
+        v_count > MAX_BLOCK_PREFIX_MERGE_VERTICES) {
+        DEBUG_PRINTF("prefixes too big already\n");
+        return false;
+    }
+
+    DEBUG_PRINTF("trying merge\n");
+    NGHolder h;
+    cloneHolder(h, *g[v].left.graph);
+    if (!mergeNfaPair(*g[u].left.graph, h, nullptr, build.cc)) {
+        DEBUG_PRINTF("couldn't merge\n");
+        return false;
+    }
+
+    const size_t merged_count = num_vertices(h);
+    DEBUG_PRINTF("merged result has %zu vertices\n", merged_count);
+    if (merged_count > MAX_BLOCK_PREFIX_MERGE_VERTICES) {
+        DEBUG_PRINTF("exceeded limit\n");
+        return false;
+    }
+
+    // We want to only perform merges that take advantage of some
+    // commonality in the two input graphs, so we check that the number of
+    // vertices has only grown a small amount: somewhere between the sum
+    // (no commonality) and the max (no growth at all) of the vertex counts
+    // of the input graphs.
+    const size_t max_size = u_count + v_count;
+    const size_t min_size = max(u_count, v_count);
+    const size_t max_growth = ((max_size - min_size) * 25) / 100;
+    if (merged_count > min_size + max_growth) {
+        DEBUG_PRINTF("grew too much\n");
+        return false;
+    }
+
+    // We don't want to squander any chances at accelerating.
+    if (!isAccelerableLeftfix(build, h) &&
+        (isAccelerableLeftfix(build, *g[u].left.graph) ||
+         isAccelerableLeftfix(build, *g[v].left.graph))) {
+        DEBUG_PRINTF("would lose accel property\n");
+        return false;
+    }
+
+    DEBUG_PRINTF("safe to merge\n");
+    return true;
+}
+
+bool mergeableRoseVertices(const RoseBuildImpl &tbi, RoseVertex u,
+                           RoseVertex v) {
+    assert(u != v);
+
+    if (!hasSameEngineType(tbi.g[u], tbi.g[v])) {
+        return false;
+    }
+
+    if (!tbi.cc.streaming && !safeBlockModeMerge(tbi, u, v)) {
+        return false;
     }
 
     /* We cannot merge prefixes/vertices if they are successors of different
@@ -883,88 +1053,104 @@ bool mergeableRoseVertices(const RoseBuildImpl &tbi, RoseVertex u,
         }
     }
 
-    // We accept any pair of literal sets A and B where no literal in A
-    // contains a literal in B and no literal in B contains a literal in A.
-
-    const u32 ulag = tbi.g[u].left.lag;
-    const u32 vlag = tbi.g[v].left.lag;
-
-    for (const u32 &ulit : ulits) {
-        const rose_literal_id &ul = tbi.literals.right.at(ulit);
-
-        if (ul.delay) {
-            return false; // We don't handle delayed cases here.
-        }
-
-        for (const u32 &vlit : vlits) {
-            const rose_literal_id &vl = tbi.literals.right.at(vlit);
-
-            if (vl.delay) {
-                return false; // We don't handle delayed cases here.
-            }
-
-            if (!checkPrefix(ul, ulag, vl, vlag) ||
-                !checkPrefix(vl, vlag, ul, ulag)) {
-                DEBUG_PRINTF("prefix check failed\n");
-                return false;
-            }
-        }
+    u32 ulag = tbi.g[u].left.lag;
+    vector<pair<const rose_literal_id *, u32>> ulits;
+    ulits.reserve(tbi.g[u].literals.size());
+    for (u32 id : tbi.g[u].literals) {
+        ulits.push_back(make_pair(&tbi.literals.right.at(id), ulag));
     }
 
-    DEBUG_PRINTF("roses on %zu and %zu are mergeable\n",
-                 tbi.g[u].idx, tbi.g[v].idx);
+    u32 vlag = tbi.g[v].left.lag;
+    vector<pair<const rose_literal_id *, u32>> vlits;
+    vlits.reserve(tbi.g[v].literals.size());
+    for (u32 id : tbi.g[v].literals) {
+        vlits.push_back(make_pair(&tbi.literals.right.at(id), vlag));
+    }
+
+    if (!compatibleLiteralsForMerge(ulits, vlits)) {
+        return false;
+    }
+
+    DEBUG_PRINTF("roses on %zu and %zu are mergeable\n", tbi.g[u].idx,
+                 tbi.g[v].idx);
     return true;
 }
 
+/* We cannot merge an engine, if a trigger literal and a post literal overlap
+ * in such a way that engine status needs to be check at a point before the
+ * engine's current location.
+ *
+ * i.e., for a trigger literal u and a pos literal v,
+ * where delta is the earliest v can appear after t,
+ * we require that v_loc - v_lag >= u_loc
+ * ==> u_loc + delta - v_lag >= u_loc
+ * ==> delta >= v_lag
+ *
+ */
 static
-bool mergeableDelays(const RoseBuildImpl &tbi, const flat_set<u32> &ulits,
-                     const flat_set<u32> &vlits, u32 vlag) {
-    for (const u32 &ulit : ulits) {
-        const rose_literal_id &ul = tbi.literals.right.at(ulit);
-        assert(!ul.delay); // this should never have got this far?
-        for (const u32 vlit : vlits) {
-            const rose_literal_id &vl = tbi.literals.right.at(vlit);
-            assert(!vl.delay); // this should never have got this far?
+bool checkPredDelay(const rose_literal_id &ul, const rose_literal_id &vl,
+                    u32 vlag) {
+    DEBUG_PRINTF("%s %s (lag %u)\n", escapeString(ul.s).c_str(),
+                 escapeString(vl.s).c_str(), vlag);
 
-            DEBUG_PRINTF("%s %s (lag %u, overlap %zu)\n",
-                         escapeString(ul.s).c_str(),
-                         escapeString(vl.s).c_str(), vlag,
-                         maxOverlap(ul, vl));
-            size_t l = vl.elength() - maxOverlap(ul, vl);
-            if (vlag > l) {
-                DEBUG_PRINTF("failed lag check!\n");
-                return false;
-            }
+    for (size_t i = 0; i < vlag; i++) {
+        if (stringsCanFinishAtSameSpot(ul.s, vl.s.begin(), vl.s.end() - i)) {
+            DEBUG_PRINTF("v can follow u at a (too close) distance of %zu\n", i);
+            return false;
         }
     }
+
+    DEBUG_PRINTF("OK\n");
     return true;
 }
 
-static
+static never_inline
 bool checkPredDelays(const RoseBuildImpl &tbi, const deque<RoseVertex> &v1,
                      const deque<RoseVertex> &v2) {
-    set<RoseVertex> preds;
+    flat_set<RoseVertex> preds;
     for (auto v : v1) {
         insert(&preds, inv_adjacent_vertices(v, tbi.g));
     }
 
+    flat_set<u32> pred_lits;
+
+    /* No need to examine delays of a common pred - as it must already have
+     * survived the delay checks.
+     *
+     * This is important when the pred is in the anchored table as
+     * the literal is no longer available. */
+    flat_set<RoseVertex> known_good_preds;
+    for (auto v : v2) {
+        insert(&known_good_preds, inv_adjacent_vertices(v, tbi.g));
+    }
+
     for (auto u : preds) {
-        const auto &pred_lits = tbi.g[u].literals;
-        for (auto v : v2) {
-            u32 vlag = tbi.g[v].left.lag;
-            DEBUG_PRINTF("consider (%zu, %zu) lag=%u\n", tbi.g[u].idx,
-                         tbi.g[v].idx, vlag);
-            if (edge_by_target(u, v, tbi.g).second) {
-                /* no need to examine delays as it is a common pred - so checks
-                 * must already have survived the delay checks.
-                 * This is important when the pred is in the anchored table as
-                 * the literal is no longer available. */
-                DEBUG_PRINTF("ok, also %zu is also a pred of %zu\n",
-                             tbi.g[u].idx, tbi.g[v].idx);
-                continue;
-            }
-            if (!mergeableDelays(tbi, pred_lits, tbi.g[v].literals, vlag)) {
-                return false;
+        if (!contains(known_good_preds, u)) {
+            insert(&pred_lits, tbi.g[u].literals);
+        }
+    }
+
+    vector<const rose_literal_id *> pred_rose_lits;
+    pred_rose_lits.reserve(pred_lits.size());
+    for (const auto &p : pred_lits) {
+        pred_rose_lits.push_back(&tbi.literals.right.at(p));
+    }
+
+    for (auto v : v2) {
+        u32 vlag = tbi.g[v].left.lag;
+        if (!vlag) {
+            continue;
+        }
+
+        for (const u32 vlit : tbi.g[v].literals) {
+            const rose_literal_id &vl = tbi.literals.right.at(vlit);
+            assert(!vl.delay); // this should never have got this far?
+            for (const auto &ul : pred_rose_lits) {
+                assert(!ul->delay); // this should never have got this far?
+
+                if (!checkPredDelay(*ul, vl, vlag)) {
+                    return false;
+                }
             }
         }
     }
@@ -976,17 +1162,65 @@ static
 bool mergeableRoseVertices(const RoseBuildImpl &tbi,
                            const deque<RoseVertex> &verts1,
                            const deque<RoseVertex> &verts2) {
-    for (auto v1 : verts1) {
-        for (auto v2 : verts2) {
-            if (!mergeableRoseVertices(tbi, v1, v2)) {
-                return false;
-            }
+    assert(!verts1.empty());
+    assert(!verts2.empty());
+
+    RoseVertex u_front = verts1.front();
+    RoseVertex v_front = verts2.front();
+
+    /* all vertices must have the same engine type: assume all verts in each
+     * group are already of the same type */
+    if (!hasSameEngineType(tbi.g[u_front], tbi.g[v_front])) {
+        return false;
+    }
+
+    bool is_prefix = tbi.isRootSuccessor(u_front);
+
+    /* We cannot merge prefixes/vertices if they are successors of different
+     * root vertices: similarly, assume the grouped vertices are compatible */
+    if (is_prefix) {
+        assert(tbi.isRootSuccessor(v_front));
+        set<RoseVertex> u_preds;
+        set<RoseVertex> v_preds;
+        insert(&u_preds, inv_adjacent_vertices(u_front, tbi.g));
+        insert(&v_preds, inv_adjacent_vertices(v_front, tbi.g));
+
+        if (u_preds != v_preds) {
+            return false;
         }
     }
 
+    vector<pair<const rose_literal_id *, u32>> ulits; /* lit + lag pairs */
+    for (auto a : verts1) {
+        if (!tbi.cc.streaming && !safeBlockModeMerge(tbi, u_front, a)) {
+            return false;
+        }
+
+        u32 ulag = tbi.g[a].left.lag;
+        for (u32 id : tbi.g[a].literals) {
+            ulits.push_back(make_pair(&tbi.literals.right.at(id), ulag));
+        }
+    }
+
+    vector<pair<const rose_literal_id *, u32>> vlits;
+    for (auto a : verts2) {
+        if (!tbi.cc.streaming && !safeBlockModeMerge(tbi, u_front, a)) {
+            return false;
+        }
+
+        u32 vlag = tbi.g[a].left.lag;
+        for (u32 id : tbi.g[a].literals) {
+            vlits.push_back(make_pair(&tbi.literals.right.at(id), vlag));
+        }
+    }
+
+    if (!compatibleLiteralsForMerge(ulits, vlits)) {
+        return false;
+    }
+
     // Check preds are compatible as well.
-    if (!checkPredDelays(tbi, verts1, verts2) ||
-        !checkPredDelays(tbi, verts2, verts1)) {
+    if (!checkPredDelays(tbi, verts1, verts2)
+        || !checkPredDelays(tbi, verts2, verts1)) {
         return false;
     }
 
@@ -1741,33 +1975,31 @@ void mergeNfaLeftfixes(RoseBuildImpl &tbi, RoseBouquet &roses) {
 }
 
 static
-void mergeCastleRoses(RoseBuildImpl &tbi, RoseBouquet &roses) {
+void mergeCastleChunk(RoseBuildImpl &tbi, RoseBouquet &cands) {
+    /* caller must have already ensured that candidates have the same reach */
     RoseGraph &g = tbi.g;
-    DEBUG_PRINTF("%zu castle rose merge candidates\n", roses.size());
+    DEBUG_PRINTF("%zu castle rose merge candidates\n", cands.size());
 
     deque<left_id> merged;
 
-    for (auto it = roses.begin(); it != roses.end(); ++it) {
+    for (auto it = cands.begin(); it != cands.end(); ++it) {
         left_id r1 = *it;
         CastleProto &castle1 = *r1.castle();
-        const deque<RoseVertex> &verts1 = roses.vertices(r1);
+        const deque<RoseVertex> &verts1 = cands.vertices(r1);
 
         merged.clear();
 
-        for (auto jt = next(it); jt != roses.end(); ++jt) {
+        for (auto jt = next(it); jt != cands.end(); ++jt) {
             left_id r2 = *jt;
             CastleProto &castle2 = *r2.castle();
-            const deque<RoseVertex> &verts2 = roses.vertices(r2);
+            const deque<RoseVertex> &verts2 = cands.vertices(r2);
 
             if (castle1.repeats.size() == castle1.max_occupancy) {
                 DEBUG_PRINTF("castle1 has hit max occupancy\n");
                 break; // next castle1
             }
 
-            if (castle1.reach() != castle2.reach()) {
-                DEBUG_PRINTF("different reach\n");
-                continue; // next castle2
-            }
+            assert(castle1.reach() == castle2.reach());
 
             if (!mergeableRoseVertices(tbi, verts1, verts2)) {
                 DEBUG_PRINTF("not mergeable\n");
@@ -1793,12 +2025,12 @@ void mergeCastleRoses(RoseBuildImpl &tbi, RoseBouquet &roses) {
                 }
             }
 
-            roses.insert(r1, verts2);
+            cands.insert(r1, verts2);
             merged.push_back(r2);
         }
 
         DEBUG_PRINTF("%zu roses merged\n", merged.size());
-        roses.erase_all(merged.begin(), merged.end());
+        cands.erase_all(merged.begin(), merged.end());
     }
 }
 
@@ -1924,13 +2156,13 @@ void mergeCastleLeftfixes(RoseBuildImpl &tbi) {
     for (auto &m : by_reach) {
         DEBUG_PRINTF("%zu castles for reach: %s\n", m.second.size(),
                      describeClass(m.first).c_str());
-        RoseBouquet &roses = m.second;
-        deque<RoseBouquet> rose_groups;
-        chunkBouquets(roses, rose_groups, MERGE_GROUP_SIZE_MAX);
-        roses.clear();
+        RoseBouquet &candidates = m.second;
+        deque<RoseBouquet> cand_groups;
+        chunkBouquets(candidates, cand_groups, MERGE_CASTLE_GROUP_SIZE_MAX);
+        candidates.clear();
 
-        for (auto &group : rose_groups) {
-            mergeCastleRoses(tbi, group);
+        for (auto &group : cand_groups) {
+            mergeCastleChunk(tbi, group);
         }
     }
 }
@@ -2185,9 +2417,6 @@ void mergeOutfixInfo(OutfixInfo &winner, const OutfixInfo &victim) {
     // layer at runtime will protect us from extra matches if only one was in
     // the small block matcher.
     winner.in_sbmatcher &= victim.in_sbmatcher;
-
-    // We should never have merged outfixes that differ in these properties.
-    assert(winner.chained == victim.chained);
 }
 
 static
@@ -2219,8 +2448,9 @@ void mergeOutfixNfas(RoseBuildImpl &tbi, vector<NGHolder *> &nfas) {
 
     map<NGHolder *, size_t> nfa_mapping;
     for (size_t i = 0; i < outfixes.size(); i++) {
-        if (outfixes[i].holder) {
-            nfa_mapping[outfixes[i].holder.get()] = i;
+        auto *holder = outfixes[i].holder();
+        if (holder) {
+            nfa_mapping[holder] = i;
         }
     }
 
@@ -2252,10 +2482,6 @@ struct MergeMcClellan {
         return mergeTwoDfas(d1, d2, DFA_MERGE_MAX_STATES, &rm, grey);
     }
 
-    static void transfer(OutfixInfo &outfix, unique_ptr<raw_dfa> d) {
-        outfix.rdfa = move(d);
-    }
-
 private:
     const ReportManager &rm;
     const Grey &grey;
@@ -2270,10 +2496,6 @@ struct MergeHaig {
         return attemptToMergeHaig({d1, d2}, limit);
     }
 
-    static void transfer(OutfixInfo &outfix, unique_ptr<raw_som_dfa> d) {
-        outfix.haig = move(d);
-    }
-
 private:
     const u32 limit; //!< state limit for merged result.
 };
@@ -2320,7 +2542,7 @@ void pairwiseDfaMerge(vector<RawDfa *> &dfas,
             RawDfa *dfa_ptr = rdfa.get();
             dfa_mapping[dfa_ptr] = dfa_mapping[*it];
             dfa_mapping.erase(*it);
-            merge_func.transfer(winner, move(rdfa));
+            winner.proto = move(rdfa);
 
             mergeOutfixInfo(winner, victim);
 
@@ -2370,8 +2592,9 @@ void mergeOutfixDfas(RoseBuildImpl &tbi, vector<raw_dfa *> &dfas) {
      * element addition. */
     ue2::unordered_map<raw_dfa *, size_t> dfa_mapping;
     for (size_t i = 0; i < outfixes.size(); i++) {
-        if (outfixes[i].rdfa) {
-            dfa_mapping[outfixes[i].rdfa.get()] = i;
+        auto *rdfa = outfixes[i].rdfa();
+        if (rdfa) {
+            dfa_mapping[rdfa] = i;
         }
     }
 
@@ -2392,10 +2615,10 @@ void mergeOutfixCombo(RoseBuildImpl &tbi, const ReportManager &rm,
     bool seen_dfa = false;
     u32 nfa_count = 0;
     for (const auto &outfix : tbi.outfixes) {
-        if (outfix.holder) {
+        if (outfix.holder()) {
             DEBUG_PRINTF("nfa\n");
             nfa_count++;
-        } else if (outfix.rdfa) {
+        } else if (outfix.rdfa()) {
             DEBUG_PRINTF("dfa\n");
             seen_dfa = true;
         }
@@ -2415,31 +2638,28 @@ void mergeOutfixCombo(RoseBuildImpl &tbi, const ReportManager &rm,
     vector<raw_dfa *> dfas;
 
     for (auto it = tbi.outfixes.begin(); it != tbi.outfixes.end(); ++it) {
-        assert(!it->is_dead());
-        if (it->nfa) {
-            assert(!it->rdfa && !it->holder && !it->haig);
-            continue;
-        }
-        assert(!it->chained);
-        if (it->rdfa) {
-            dfas.push_back(it->rdfa.get());
-            dfa_mapping[it->rdfa.get()] = it - tbi.outfixes.begin();
+        auto &outfix = *it;
+        assert(!outfix.is_dead());
+
+        if (outfix.rdfa()) {
+            auto *rdfa = outfix.rdfa();
+            dfas.push_back(rdfa);
+            dfa_mapping[rdfa] = it - tbi.outfixes.begin();
             continue;
         }
 
-        if (!it->holder) {
+        if (!outfix.holder()) {
             continue;
         }
 
-        NGHolder *h = it->holder.get();
+        NGHolder *h = outfix.holder();
         assert(h->kind == NFA_OUTFIX);
         auto rdfa = buildMcClellan(*h, &rm, grey);
         if (rdfa) {
             // Transform this outfix into a DFA and add it to the merge set.
             dfa_mapping[rdfa.get()] = it - tbi.outfixes.begin();
             dfas.push_back(rdfa.get());
-            it->clear();
-            it->rdfa = move(rdfa);
+            outfix.proto = move(rdfa);
             new_dfas++;
         }
     }
@@ -2467,8 +2687,9 @@ void mergeOutfixHaigs(RoseBuildImpl &tbi, vector<raw_som_dfa *> &dfas,
 
     ue2::unordered_map<raw_som_dfa *, size_t> dfa_mapping;
     for (size_t i = 0; i < outfixes.size(); i++) {
-        if (outfixes[i].haig) {
-            dfa_mapping[outfixes[i].haig.get()] = i;
+        auto *haig = outfixes[i].haig();
+        if (haig) {
+            dfa_mapping[haig] = i;
         }
     }
 
@@ -2493,18 +2714,13 @@ void mergeOutfixes(RoseBuildImpl &tbi) {
     vector<raw_dfa *> dfas;
     vector<raw_som_dfa *> som_dfas;
 
-    for (const auto &outfix : tbi.outfixes) {
-        if (outfix.nfa) {
-            assert(!outfix.rdfa && !outfix.holder && !outfix.haig);
-            continue;
-        }
-        assert(!outfix.chained);
-        if (outfix.rdfa) {
-            dfas.push_back(outfix.rdfa.get());
-        } else if (outfix.holder) {
-            nfas.push_back(outfix.holder.get());
-        } else if (outfix.haig) {
-            som_dfas.push_back(outfix.haig.get());
+    for (auto &outfix : tbi.outfixes) {
+        if (outfix.rdfa()) {
+            dfas.push_back(outfix.rdfa());
+        } else if (outfix.holder()) {
+            nfas.push_back(outfix.holder());
+        } else if (outfix.haig()) {
+            som_dfas.push_back(outfix.haig());
         }
     }
 
@@ -2609,7 +2825,7 @@ void mergePuffixes(RoseBuildImpl &tbi) {
         u32 squashDistance =
             allowedSquashDistance(repeat.reach, repeat.bounds.min, tbi, v);
 
-        Report ir = makeRoseTrigger(event, squashDistance);
+        Report ir = makeMpvTrigger(event, squashDistance);
         ReportID id = tbi.rm.getInternalId(ir);
 
         DEBUG_PRINTF("puffette event q%u t%u\n", queue, event);
diff --git a/src/rose/rose_build_misc.cpp b/src/rose/rose_build_misc.cpp
index cc5bbc70..b16e3a69 100644
--- a/src/rose/rose_build_misc.cpp
+++ b/src/rose/rose_build_misc.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -78,9 +78,7 @@ RoseBuildImpl::RoseBuildImpl(ReportManager &rm_in, SomSlotManager &ssm_in,
       group_weak_end(0),
       group_end(0),
       anchored_base_id(MO_INVALID_IDX),
-      nonbenefits_base_id(MO_INVALID_IDX),
       ematcher_region_size(0),
-      floating_direct_report(false),
       eod_event_literal_id(MO_INVALID_IDX),
       max_rose_anchored_floating_overlap(0),
       rm(rm_in),
@@ -89,12 +87,10 @@ RoseBuildImpl::RoseBuildImpl(ReportManager &rm_in, SomSlotManager &ssm_in,
       next_nfa_report(0) {
     // add root vertices to graph
     g[root].idx = vertexIndex++;
-    g[root].role = MO_INVALID_IDX;
     g[root].min_offset = 0;
     g[root].max_offset = 0;
 
     g[anchored_root].idx = vertexIndex++;
-    g[anchored_root].role = MO_INVALID_IDX;
     g[anchored_root].min_offset = 0;
     g[anchored_root].max_offset = 0;
 }
@@ -194,7 +190,7 @@ bool RoseBuildImpl::hasLiteralInTable(RoseVertex v,
 bool RoseBuildImpl::hasNoFloatingRoots() const {
     for (auto v : adjacent_vertices_range(root, g)) {
         if (isFloating(v)) {
-            DEBUG_PRINTF("direct floating root %u\n", g[v].role);
+            DEBUG_PRINTF("direct floating root %zu\n", g[v].idx);
             return false;
         }
     }
@@ -202,7 +198,7 @@ bool RoseBuildImpl::hasNoFloatingRoots() const {
     /* need to check if the anchored_root has any literals which are too deep */
     for (auto v : adjacent_vertices_range(anchored_root, g)) {
         if (isFloating(v)) {
-            DEBUG_PRINTF("indirect floating root %u\n", g[v].role);
+            DEBUG_PRINTF("indirect floating root %zu\n", g[v].idx);
             return false;
         }
     }
@@ -210,22 +206,6 @@ bool RoseBuildImpl::hasNoFloatingRoots() const {
     return true;
 }
 
-bool RoseBuildImpl::hasEodSideLink(void) const {
-    for (auto v : vertices_range(g)) {
-        if (!g[v].eod_accept) {
-            continue;
-        }
-
-        for (auto u : inv_adjacent_vertices_range(v, g)) {
-            if (g[u].escapes.any()) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
 size_t RoseBuildImpl::maxLiteralLen(RoseVertex v) const {
     const auto &lit_ids = g[v].literals;
     assert(!lit_ids.empty());
@@ -320,6 +300,23 @@ const rose_literal_id &getOverlapLiteral(const RoseBuildImpl &tbi,
     return tbi.literals.right.at(literal_id);
 }
 
+ue2_literal findNonOverlappingTail(const set<ue2_literal> &lits,
+                                   const ue2_literal &s) {
+    size_t max_overlap = 0;
+
+    for (const auto &lit : lits) {
+        size_t overlap = lit != s ? maxStringOverlap(lit, s)
+                                  : maxStringSelfOverlap(s);
+        max_overlap = max(max_overlap, overlap);
+    }
+
+    /* find the tail that doesn't overlap */
+    ue2_literal tail = s.substr(max_overlap);
+    DEBUG_PRINTF("%zu overlap, tail: '%s'\n", max_overlap,
+                 dumpString(tail).c_str());
+    return tail;
+}
+
 size_t RoseBuildImpl::maxLiteralOverlap(RoseVertex u, RoseVertex v) const {
     size_t overlap = 0;
     for (auto u_lit_id : g[u].literals) {
@@ -628,23 +625,54 @@ RoseDedupeAuxImpl::RoseDedupeAuxImpl(const RoseBuildImpl &tbi_in)
     }
 
     for (const auto &outfix : tbi.outfixes) {
-        assert(!outfix.nfa); /* should not be built yet */
-
         for (const auto &report_id : all_reports(outfix)) {
             outfix_map[report_id].insert(&outfix);
         }
     }
 
     if (tbi.mpv_outfix) {
-        for (const auto &puff : tbi.mpv_outfix->puffettes) {
+        auto *mpv = tbi.mpv_outfix->mpv();
+        for (const auto &puff : mpv->puffettes) {
             puff_map[puff.report].insert(&puff);
         }
-        for (const auto &puff : tbi.mpv_outfix->triggered_puffettes) {
+        for (const auto &puff : mpv->triggered_puffettes) {
             puff_map[puff.report].insert(&puff);
         }
     }
 }
 
+static
+vector<CharReach> makePath(const rose_literal_id &lit) {
+    vector<CharReach> path(begin(lit.s), end(lit.s));
+    for (u32 i = 0; i < lit.delay; i++) {
+        path.push_back(CharReach::dot());
+    }
+    return path;
+}
+
+/**
+ * \brief True if one of the given literals overlaps with the suffix of
+ * another, meaning that they could arrive at the same offset.
+ */
+static
+bool literalsCouldRace(const rose_literal_id &lit1,
+                       const rose_literal_id &lit2) {
+    DEBUG_PRINTF("compare %s (delay %u) and %s (delay %u)\n",
+                 dumpString(lit1.s).c_str(), lit1.delay,
+                 dumpString(lit2.s).c_str(), lit2.delay);
+
+    // Add dots on the end of each literal for delay.
+    const auto v1 = makePath(lit1);
+    const auto v2 = makePath(lit2);
+
+    // See if the smaller path is a suffix of the larger path.
+    const auto *smaller = v1.size() < v2.size() ? &v1 : &v2;
+    const auto *bigger = v1.size() < v2.size() ? &v2 : &v1;
+    auto r = mismatch(smaller->rbegin(), smaller->rend(), bigger->rbegin(),
+                      overlaps);
+    return r.first == smaller->rend();
+}
+
 bool RoseDedupeAuxImpl::requiresDedupeSupport(
     const ue2::flat_set<ReportID> &reports) const {
     /* TODO: this could be expanded to check for offset or character
@@ -652,7 +680,6 @@ bool RoseDedupeAuxImpl::requiresDedupeSupport(
 
     const RoseGraph &g = tbi.g;
 
-    bool has_role = false;
     bool has_suffix = false;
     bool has_outfix = false;
 
@@ -685,24 +712,40 @@ bool RoseDedupeAuxImpl::requiresDedupeSupport(
     }
 
     /* roles */
+
+    map<u32, u32> lits; // Literal ID -> count of occurrences.
+
+    const bool has_role = !roles.empty();
     for (auto v : roles) {
-        if (has_role) {
-            return true; /* fear that multiple roles may trigger at same
-                            offset */
+        for (const auto &lit : g[v].literals) {
+            lits[lit]++;
         }
-
-        has_role = true;
-
-        /* TODO: extend handled roles so that we don't have to worry about
-         * multiple literals */
-        if (g[v].literals.size() > 1) {
-            return true; /* fear that role may be triggered multiple times
-                          * at same offset. */
-        }
-
         if (g[v].eod_accept) {
-            if (in_degree(v, g) > 1) {
-                /* may actually map to a number of terminal vertices */
+            // Literals plugged into this EOD accept must be taken into account
+            // as well.
+            for (auto u : inv_adjacent_vertices_range(v, g)) {
+                for (const auto &lit : g[u].literals) {
+                    lits[lit]++;
+                }
+            }
+        }
+    }
+
+    /* literals */
+
+    for (const auto &m : lits) {
+        if (m.second > 1) {
+            DEBUG_PRINTF("lit %u used by >1 reporting roles\n", m.first);
+            return true;
+        }
+    }
+
+    for (auto it = begin(lits); it != end(lits); ++it) {
+        const auto &lit1 = tbi.literals.right.at(it->first);
+        for (auto jt = next(it); jt != end(lits); ++jt) {
+            const auto &lit2 = tbi.literals.right.at(jt->first);
+            if (literalsCouldRace(lit1, lit2)) {
+                DEBUG_PRINTF("literals could race\n");
                 return true;
             }
         }
@@ -737,19 +780,19 @@ bool RoseDedupeAuxImpl::requiresDedupeSupport(
     for (const auto &outfix_ptr : outfixes) {
         assert(outfix_ptr);
         const OutfixInfo &out = *outfix_ptr;
-        assert(!out.nfa); /* should not be built yet */
 
         if (has_outfix || has_role || has_suffix) {
             return true;
         }
         has_outfix = true;
 
-        if (out.haig) {
+        if (out.haig()) {
             return true; /* haig may report matches with different SOM at the
                             same offset */
         }
 
-        if (out.holder && requiresDedupe(*out.holder, reports, tbi.cc.grey)) {
+        if (out.holder() &&
+            requiresDedupe(*out.holder(), reports, tbi.cc.grey)) {
             return true;
         }
     }
@@ -833,25 +876,33 @@ u32 OutfixInfo::get_queue(QueueIndexFactory &qif) {
     return queue;
 }
 
+namespace {
+class OutfixAllReports : public boost::static_visitor<set<ReportID>> {
+public:
+    set<ReportID> operator()(const boost::blank &) const {
+        return {};
+    }
+
+    template<class T>
+    set<ReportID> operator()(const unique_ptr<T> &x) const {
+        return all_reports(*x);
+    }
+
+    set<ReportID> operator()(const MpvProto &mpv) const {
+        set<ReportID> reports;
+        for (const auto &puff : mpv.puffettes) {
+            reports.insert(puff.report);
+        }
+        for (const auto &puff : mpv.triggered_puffettes) {
+            reports.insert(puff.report);
+        }
+        return reports;
+    }
+};
+}
+
 set<ReportID> all_reports(const OutfixInfo &outfix) {
-    set<ReportID> reports;
-    if (outfix.holder) {
-        insert(&reports, all_reports(*outfix.holder));
-    }
-    if (outfix.rdfa) {
-        insert(&reports, all_reports(*outfix.rdfa));
-    }
-    if (outfix.haig) {
-        insert(&reports, all_reports(*outfix.haig));
-    }
-
-    for (const auto &puff : outfix.puffettes) {
-        reports.insert(puff.report);
-    }
-    for (const auto &puff : outfix.triggered_puffettes) {
-        reports.insert(puff.report);
-    }
-
+    auto reports = boost::apply_visitor(OutfixAllReports(), outfix.proto);
     assert(!reports.empty());
     return reports;
 }
@@ -1112,39 +1163,6 @@ LeftEngInfo::operator bool() const {
     return graph || castle || dfa || haig;
 }
 
-// Find the minimum depth in hops of each role. Note that a role may be
-// accessible from both the root and the anchored root.
-map<RoseVertex, u32> findDepths(const RoseBuildImpl &build) {
-    const RoseGraph &g = build.g;
-    map<RoseVertex, u32> depths;
-
-    depths[build.root] = 0;
-    depths[build.anchored_root] = 0;
-
-    // BFS from root first.
-    breadth_first_search(g, build.root, visitor(make_bfs_visitor(
-            record_distances(boost::make_assoc_property_map(depths),
-                             boost::on_tree_edge()))).
-            vertex_index_map(get(&RoseVertexProps::idx, g)));
-
-    // BFS from anchored root, updating depths in the graph when they get
-    // smaller.
-    map<RoseVertex, u32> depthsAnch;
-    breadth_first_search(g, build.anchored_root, visitor(make_bfs_visitor(
-            record_distances(boost::make_assoc_property_map(depthsAnch),
-                             boost::on_tree_edge()))).
-            vertex_index_map(get(&RoseVertexProps::idx, g)));
-    for (const auto &e : depthsAnch) {
-        if (contains(depths, e.first)) {
-            LIMIT_TO_AT_MOST(&depths[e.first], e.second);
-        } else {
-            depths.insert(e);
-        }
-    }
-
-    return depths;
-}
-
 u32 roseQuality(const RoseEngine *t) {
     /* Rose is low quality if the atable is a Mcclellan 16 or has multiple DFAs
      */
diff --git a/src/rose/rose_build_role_aliasing.cpp b/src/rose/rose_build_role_aliasing.cpp
index 88deaa25..1f873403 100644
--- a/src/rose/rose_build_role_aliasing.cpp
+++ b/src/rose/rose_build_role_aliasing.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -347,13 +347,7 @@ bool isAliasingCandidate(RoseVertex v, const RoseBuildImpl &tbi) {
         return false;
     }
 
-    u32 id = *props.literals.begin();
-    assert(id != MO_INVALID_IDX);
-
-    // Ignore direct reports.
-    if (tbi.isDirectReport(id)) {
-        return false;
-    }
+    assert(*props.literals.begin() != MO_INVALID_IDX);
 
     // Any vertex involved in a "ghost" relationship has already been disallowed
 
@@ -365,8 +359,7 @@ bool sameRoleProperties(const RoseBuildImpl &build, RoseVertex a, RoseVertex b)
     const RoseGraph &g = build.g;
     const RoseVertexProps &aprops = g[a], &bprops = g[b];
 
-    if (aprops.eod_accept != bprops.eod_accept
-        || aprops.escapes != bprops.escapes) {
+    if (aprops.eod_accept != bprops.eod_accept) {
         return false;
     }
 
@@ -457,12 +450,6 @@ size_t hashRightRoleProperties(RoseVertex v, const RoseGraph &g) {
 
 static
 void removeVertexFromMaps(RoseVertex v, RoseBuildImpl &build, revRoseMap &rrm) {
-    // Remove vertex 'a' from literal squash roles.  Only sidecar literals can
-    // squash vertices, so they're the only ones we have to check.
-    for (auto &roles : build.side_squash_roles | map_values) {
-        roles.erase(v);
-    }
-
     if (build.g[v].left) {
         const left_id left(build.g[v].left);
         assert(contains(rrm[left], v));
@@ -558,7 +545,6 @@ void mergeVertices(RoseVertex a, RoseVertex b, RoseBuildImpl &tbi,
 
     // Merge role properties.
     assert(g[a].eod_accept == g[b].eod_accept);
-    assert(g[a].escapes == g[b].escapes);
     assert(g[a].left == g[b].left);
 
     insert(&g[b].reports, g[a].reports);
@@ -596,7 +582,6 @@ void mergeVerticesDiamond(RoseVertex a, RoseVertex b, RoseBuildImpl &tbi,
     // Merge role properties. For a diamond merge, most properties are already
     // the same (with the notable exception of the literal set).
     assert(g[a].eod_accept == g[b].eod_accept);
-    assert(g[a].escapes == g[b].escapes);
     assert(g[a].left == g[b].left);
     assert(g[a].reports == g[b].reports);
     assert(g[a].suffix == g[b].suffix);
diff --git a/src/rose/rose_build_util.h b/src/rose/rose_build_util.h
index fe2124a0..536b031a 100644
--- a/src/rose/rose_build_util.h
+++ b/src/rose/rose_build_util.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -36,21 +36,6 @@
 
 namespace ue2 {
 
-// Calculate the minimum depth for the given set of vertices, ignoring those
-// with depth 1.
-template<class Cont>
-static
-u8 calcMinDepth(const std::map<RoseVertex, u32> &depths, const Cont &verts) {
-    u8 d = 255;
-    for (RoseVertex v : verts) {
-        u8 vdepth = (u8)std::min((u32)255, depths.at(v));
-        if (vdepth > 1) {
-            d = std::min(d, vdepth);
-        }
-    }
-    return d;
-}
-
 // Comparator for vertices using their index property.
 struct VertexIndexComp {
     VertexIndexComp(const RoseGraph &gg) : g(gg) {}
diff --git a/src/rose/rose_dump.cpp b/src/rose/rose_dump.cpp
index 4c4f4a79..f6badd1b 100644
--- a/src/rose/rose_dump.cpp
+++ b/src/rose/rose_dump.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -34,15 +34,15 @@
 #include "rose_dump.h"
 #include "rose_common.h"
 #include "rose_internal.h"
+#include "rose_program.h"
 #include "hs_compile.h"
 #include "ue2common.h"
 #include "nfa/nfa_build_util.h"
 #include "nfa/nfa_dump_api.h"
 #include "nfa/nfa_internal.h"
-#include "sidecar/sidecar.h"
-#include "sidecar/sidecar_compile.h"
-#include "sidecar/sidecar_dump.h"
+#include "util/dump_charclass.h"
 #include "util/multibit_internal.h"
+#include "util/multibit.h"
 
 #include <algorithm>
 #include <fstream>
@@ -106,11 +106,6 @@ const HWLM *getFloatingMatcher(const RoseEngine *t) {
     return (const HWLM *)loadFromByteCodeOffset(t, t->fmatcherOffset);
 }
 
-static
-const sidecar *getSidecarMatcher(const RoseEngine *t) {
-    return (const sidecar *)loadFromByteCodeOffset(t, t->smatcherOffset);
-}
-
 static
 const HWLM *getEodMatcher(const RoseEngine *t) {
     return (const HWLM *)loadFromByteCodeOffset(t, t->ematcherOffset);
@@ -122,179 +117,460 @@ const HWLM *getSmallBlockMatcher(const RoseEngine *t) {
 }
 
 static
-const RosePred *getPredTable(const RoseEngine *t, u32 *count) {
-    *count = t->predCount;
-    return (const RosePred *)loadFromByteCodeOffset(t, t->predOffset);
-}
+CharReach bitvectorToReach(const u8 *reach) {
+    CharReach cr;
 
-static
-u32 literalsWithDepth(const RoseEngine *t, u8 depth) {
-    u32 n = 0;
-    const RoseLiteral *tl = getLiteralTable(t);
-    const RoseLiteral *tl_end = tl + t->literalCount;
+    for (size_t i = 0; i < 256; i++) {
+        if (reach[i / 8] & (1U << (i % 8))) {
+            cr.set(i);
 
-    for (; tl != tl_end; ++tl) {
-        if (tl->minDepth == depth) {
-            n++;
         }
     }
-    return n;
+    return cr;
 }
 
 static
-u32 literalsWithDirectReports(const RoseEngine *t) {
-    return t->totalNumLiterals - t->literalCount;
-}
+void dumpLookaround(ofstream &os, const RoseEngine *t,
+                    const ROSE_STRUCT_CHECK_LOOKAROUND *ri) {
+    assert(ri);
 
-template<typename member_type_ptr>
-static
-u32 literalsWithProp(const RoseEngine *t, member_type_ptr prop) {
-    u32 n = 0;
-    const RoseLiteral *tl = getLiteralTable(t);
-    const RoseLiteral *tl_end = tl + t->literalCount;
+    const u8 *base = (const u8 *)t;
+    const s8 *look_base = (const s8 *)(base + t->lookaroundTableOffset);
+    const u8 *reach_base = base + t->lookaroundReachOffset;
 
-    for (; tl != tl_end; ++tl) {
-        if (tl->*prop) {
-            n++;
-        }
+    const s8 *look = look_base + ri->index;
+    const s8 *look_end = look + ri->count;
+    const u8 *reach = reach_base + ri->index * REACH_BITVECTOR_LEN;
+
+    os << "    contents:" << endl;
+
+    for (; look < look_end; look++, reach += REACH_BITVECTOR_LEN) {
+        os << "      " << std::setw(4) << std::setfill(' ') << int{*look}
+           << ": ";
+        describeClass(os, bitvectorToReach(reach), 1000, CC_OUT_TEXT);
+        os << endl;
     }
-    return n;
-}
-
-template<typename member_type>
-static
-u32 rolesWithPropValue(const RoseEngine *t, member_type RoseRole::*prop,
-                       member_type value) {
-    u32 n = 0;
-    const RoseRole *tr = getRoleTable(t);
-    const RoseRole *tr_end = tr + t->roleCount;
-
-    for (; tr != tr_end; ++tr) {
-        if (tr->*prop == value) {
-            n++;
-        }
-    }
-    return n;
 }
 
 static
-u32 literalsInGroups(const RoseEngine *t, u32 from, u32 to) {
-    u32 n = 0;
-    const RoseLiteral *tl = getLiteralTable(t);
-    const RoseLiteral *tl_end = tl + t->literalCount;
+vector<u32> sparseIterValues(const mmbit_sparse_iter *it, u32 num_bits) {
+    vector<u32> keys;
 
-    rose_group mask = ~((1ULL << from) - 1);
-    if (to < 64) {
-        mask &= ((1ULL << to) - 1);
+    if (num_bits == 0) {
+        return keys;
     }
 
-    for (; tl != tl_end; ++tl) {
-        if (tl->groups & mask) {
-            n++;
-        }
+    vector<u8> bits(mmbit_size(num_bits), u8{0xff}); // All bits on.
+    vector<mmbit_sparse_state> state(MAX_SPARSE_ITER_STATES);
+
+    const u8 *b = bits.data();
+    mmbit_sparse_state *s = state.data();
+
+    u32 idx = 0;
+    u32 i = mmbit_sparse_iter_begin(b, num_bits, &idx, it, s);
+    while (i != MMB_INVALID) {
+        keys.push_back(i);
+        i = mmbit_sparse_iter_next(b, num_bits, i, &idx, it, s);
     }
-    return n;
+
+    return keys;
 }
 
 static
-u32 rolesWithFlag(const RoseEngine *t, u32 flag) {
-    u32 n = 0;
-    const RoseRole *tr = getRoleTable(t);
-    const RoseRole *tr_end = tr + t->roleCount;
+void dumpJumpTable(ofstream &os, const RoseEngine *t,
+                   const ROSE_STRUCT_SPARSE_ITER_BEGIN *ri) {
+    auto *it =
+        (const mmbit_sparse_iter *)loadFromByteCodeOffset(t, ri->iter_offset);
+    auto *jumps = (const u32 *)loadFromByteCodeOffset(t, ri->jump_table);
 
-    for (; tr != tr_end; ++tr) {
-        if (tr->flags & flag) {
-            n++;
-        }
+    for (const auto &key : sparseIterValues(it, t->rolesWithStateCount)) {
+        os << "      " << std::setw(4) << std::setfill(' ') << key << " : +"
+           << *jumps << endl;
+        ++jumps;
     }
-    return n;
 }
 
 static
-u32 rolesWithSuffixes(const RoseEngine *t) {
-    u32 n = 0;
-    const RoseRole *tr = getRoleTable(t);
-    const RoseRole *tr_end = tr + t->roleCount;
-
-    for (; tr != tr_end; ++tr) {
-        if (tr->suffixOffset) {
-            n++;
-        }
-    }
-    return n;
-}
-
-static
-u32 rolesWithLookaround(const RoseEngine *t) {
-    u32 n = 0;
-    const RoseRole *tr = getRoleTable(t);
-    const RoseRole *tr_end = tr + t->roleCount;
-
-    for (; tr != tr_end; ++tr) {
-        if (tr->lookaroundIndex != MO_INVALID_IDX) {
-            n++;
-        }
-    }
-    return n;
-}
-
-// Count roles that fire reports
-static
-u32 rolesWithReports(const RoseEngine *t) {
-    u32 n = 0;
-    const RoseRole *tr = getRoleTable(t);
-    const RoseRole *tr_end = tr + t->roleCount;
-
-    for (; tr != tr_end; ++tr) {
-        if (tr->reportId != MO_INVALID_IDX) {
-            n++;
-        }
-    }
-    return n;
-}
-
-static
-const char *historyName(RoseRoleHistory h) {
-    switch (h) {
-    case ROSE_ROLE_HISTORY_NONE:
-        return "history none";
-    case ROSE_ROLE_HISTORY_ANCH:
-        return "history anch";
-    case ROSE_ROLE_HISTORY_LAST_BYTE:
-        return "history last_byte";
+void dumpSomOperation(ofstream &os, const som_operation &op) {
+    os << "    som (type=" << u32{op.type} << ", onmatch=" << op.onmatch;
+    switch (op.type) {
+    case SOM_EXTERNAL_CALLBACK_REV_NFA:
+    case SOM_INTERNAL_LOC_SET_REV_NFA:
+    case SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET:
+    case SOM_INTERNAL_LOC_SET_REV_NFA_IF_WRITABLE:
+        os << ", revNfaIndex=" << op.aux.revNfaIndex;
+        break;
     default:
-        return "unknown";
+        os << ", somDistance=" << op.aux.somDistance;
+        break;
     }
+    os << ")" << endl;
 }
 
 static
-void dumpPreds(FILE *f, const RoseEngine *t) {
-    map<RoseRoleHistory, u32> counts;
+string dumpStrMask(const u8 *mask, size_t len) {
+    ostringstream oss;
+    for (size_t i = 0; i < len; i++) {
+        oss << std::hex << std::setw(2) << std::setfill('0') << u32{mask[i]}
+            << " ";
+    }
+    return oss.str();
+}
 
-    u32 predCount = 0;
-    const RosePred *tp = getPredTable(t, &predCount);
-    const RosePred *tp_end = tp + predCount;
+#define PROGRAM_CASE(name)                                                     \
+    case ROSE_INSTR_##name: {                                                  \
+        os << "  " << std::setw(4) << std::setfill('0') << (pc - pc_base)      \
+           << ": " #name " (" << (int)ROSE_INSTR_##name << ")" << endl;        \
+        const auto *ri = (const struct ROSE_STRUCT_##name *)pc;
 
-    for (; tp != tp_end; ++tp) {
-        assert(tp->historyCheck < ROSE_ROLE_HISTORY_INVALID);
-        counts[(RoseRoleHistory)tp->historyCheck] += 1;
+#define PROGRAM_NEXT_INSTRUCTION                                               \
+    pc += ROUNDUP_N(sizeof(*ri), ROSE_INSTR_MIN_ALIGN);                        \
+    break;                                                                     \
     }
 
-    for (map<RoseRoleHistory, u32>::const_iterator it = counts.begin(),
-                                                    ite = counts.end();
-         it != ite; ++it) {
-        fprintf(f, " - %-18s: %u\n", historyName(it->first), it->second);
+static
+void dumpProgram(ofstream &os, const RoseEngine *t, const char *pc) {
+    const char *pc_base = pc;
+    for (;;) {
+        u8 code = *(const u8 *)pc;
+        assert(code <= ROSE_INSTR_END);
+        const size_t offset = pc - pc_base;
+        switch (code) {
+            PROGRAM_CASE(ANCHORED_DELAY) {
+                os << "    groups 0x" << std::hex << ri->groups << std::dec
+                   << endl;
+                os << "    done_jump " << offset + ri->done_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_LIT_MASK) {
+                os << "    and_mask "
+                   << dumpStrMask(ri->and_mask.a8, sizeof(ri->and_mask.a8))
+                   << endl;
+                os << "    cmp_mask "
+                   << dumpStrMask(ri->cmp_mask.a8, sizeof(ri->cmp_mask.a8))
+                   << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_LIT_EARLY) {}
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_GROUPS) {
+                os << "    groups 0x" << std::hex << ri->groups << std::dec
+                   << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_ONLY_EOD) {
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_BOUNDS) {
+                os << "    min_bound " << ri->min_bound << endl;
+                os << "    max_bound " << ri->max_bound << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_NOT_HANDLED) {
+                os << "    key " << ri->key << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_LOOKAROUND) {
+                os << "    index " << ri->index << endl;
+                os << "    count " << ri->count << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+                dumpLookaround(os, t, ri);
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_INFIX) {
+                os << "    queue " << ri->queue << endl;
+                os << "    lag " << ri->lag << endl;
+                os << "    report " << ri->report << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_PREFIX) {
+                os << "    queue " << ri->queue << endl;
+                os << "    lag " << ri->lag << endl;
+                os << "    report " << ri->report << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(PUSH_DELAYED) {
+                os << "    delay " << u32{ri->delay} << endl;
+                os << "    index " << ri->index << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CATCH_UP) {}
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CATCH_UP_MPV) {}
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SOM_ADJUST) {
+                os << "    distance " << ri->distance << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SOM_LEFTFIX) {
+                os << "    queue " << ri->queue << endl;
+                os << "    lag " << ri->lag << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SOM_FROM_REPORT) {
+                dumpSomOperation(os, ri->som);
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SOM_ZERO) {}
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(TRIGGER_INFIX) {
+                os << "    queue " << ri->queue << endl;
+                os << "    event " << ri->event << endl;
+                os << "    cancel " << u32{ri->cancel} << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(TRIGGER_SUFFIX) {
+                os << "    queue " << ri->queue << endl;
+                os << "    event " << ri->event << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(DEDUPE) {
+                os << "    quash_som " << u32{ri->quash_som} << endl;
+                os << "    dkey " << ri->dkey << endl;
+                os << "    offset_adjust " << ri->offset_adjust << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(DEDUPE_SOM) {
+                os << "    quash_som " << u32{ri->quash_som} << endl;
+                os << "    dkey " << ri->dkey << endl;
+                os << "    offset_adjust " << ri->offset_adjust << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_CHAIN) {
+                os << "    event " << ri->event << endl;
+                os << "    top_squash_distance " << ri->top_squash_distance
+                   << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_SOM_INT) {
+                dumpSomOperation(os, ri->som);
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_SOM_AWARE) {
+                dumpSomOperation(os, ri->som);
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT) {
+                os << "    onmatch " << ri->onmatch << endl;
+                os << "    offset_adjust " << ri->offset_adjust << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_EXHAUST) {
+                os << "    onmatch " << ri->onmatch << endl;
+                os << "    offset_adjust " << ri->offset_adjust << endl;
+                os << "    ekey " << ri->ekey << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_SOM) {
+                os << "    onmatch " << ri->onmatch << endl;
+                os << "    offset_adjust " << ri->offset_adjust << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(REPORT_SOM_EXHAUST) {
+                os << "    onmatch " << ri->onmatch << endl;
+                os << "    offset_adjust " << ri->offset_adjust << endl;
+                os << "    ekey " << ri->ekey << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(DEDUPE_AND_REPORT) {
+                os << "    quash_som " << u32{ri->quash_som} << endl;
+                os << "    dkey " << ri->dkey << endl;
+                os << "    onmatch " << ri->onmatch << endl;
+                os << "    offset_adjust " << ri->offset_adjust << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(FINAL_REPORT) {
+                os << "    onmatch " << ri->onmatch << endl;
+                os << "    offset_adjust " << ri->offset_adjust << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_EXHAUSTED) {
+                os << "    ekey " << ri->ekey << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_MIN_LENGTH) {
+                os << "    end_adj " << ri->end_adj << endl;
+                os << "    min_length " << ri->min_length << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SET_STATE) {
+                os << "    index " << ri->index << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SET_GROUPS) {
+                os << "    groups 0x" << std::hex << ri->groups << std::dec
+                   << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SQUASH_GROUPS) {
+                os << "    groups 0x" << std::hex << ri->groups << std::dec
+                   << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(CHECK_STATE) {
+                os << "    index " << ri->index << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SPARSE_ITER_BEGIN) {
+                os << "    iter_offset " << ri->iter_offset << endl;
+                os << "    jump_table " << ri->jump_table << endl;
+                dumpJumpTable(os, t, ri);
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(SPARSE_ITER_NEXT) {
+                os << "    iter_offset " << ri->iter_offset << endl;
+                os << "    jump_table " << ri->jump_table << endl;
+                os << "    state " << ri->state << endl;
+                os << "    fail_jump " << offset + ri->fail_jump << endl;
+            }
+            PROGRAM_NEXT_INSTRUCTION
+
+            PROGRAM_CASE(END) { return; }
+            PROGRAM_NEXT_INSTRUCTION
+
+        default:
+            os << "  UNKNOWN (code " << int{code} << ")" << endl;
+            os << "  <stopping>" << endl;
+            return;
+        }
     }
 }
 
+#undef PROGRAM_CASE
+#undef PROGRAM_NEXT_INSTRUCTION
+
 static
-const char *startNfaRegion(const RoseEngine *t) {
-    return (const char *)t + t->nfaRegionBegin;
+void dumpRoseLitPrograms(const RoseEngine *t, const string &filename) {
+    ofstream os(filename);
+
+    const u32 *litPrograms =
+        (const u32 *)loadFromByteCodeOffset(t, t->litProgramOffset);
+    const u32 *delayRebuildPrograms =
+        (const u32 *)loadFromByteCodeOffset(t, t->litDelayRebuildProgramOffset);
+
+    for (u32 i = 0; i < t->literalCount; i++) {
+        os << "Literal " << i << endl;
+        os << "---------------" << endl;
+
+        if (litPrograms[i]) {
+            os << "Program @ " << litPrograms[i] << ":" << endl;
+            const char *prog =
+                (const char *)loadFromByteCodeOffset(t, litPrograms[i]);
+            dumpProgram(os, t, prog);
+        } else {
+            os << "<No Program>" << endl;
+        }
+
+        if (delayRebuildPrograms[i]) {
+            os << "Delay Rebuild Program @ " << delayRebuildPrograms[i] << ":"
+               << endl;
+            const char *prog = (const char *)loadFromByteCodeOffset(
+                t, delayRebuildPrograms[i]);
+            dumpProgram(os, t, prog);
+        }
+
+        os << endl;
+    }
+
+    os.close();
 }
 
 static
-const char *endNfaRegion(const RoseEngine *t) {
-    return (const char *)t + t->nfaRegionEnd;
+void dumpRoseEodPrograms(const RoseEngine *t, const string &filename) {
+    ofstream os(filename);
+    const char *base = (const char *)t;
+
+    os << "Unconditional EOD Program:" << endl;
+
+    if (t->eodProgramOffset) {
+        dumpProgram(os, t, base + t->eodProgramOffset);
+        os << endl;
+    } else {
+        os << "<No EOD Program>" << endl;
+    }
+
+    os << "Sparse Iter EOD Program:" << endl;
+
+    if (t->eodIterProgramOffset) {
+        dumpProgram(os, t, base + t->eodIterProgramOffset);
+    } else {
+        os << "<No EOD Iter Program>" << endl;
+    }
+
+    os.close();
+}
+
+static
+void dumpRoseReportPrograms(const RoseEngine *t, const string &filename) {
+    ofstream os(filename);
+
+    const u32 *programs =
+        (const u32 *)loadFromByteCodeOffset(t, t->reportProgramOffset);
+
+    for (u32 i = 0; i < t->reportProgramCount; i++) {
+        os << "Report " << i << endl;
+        os << "---------------" << endl;
+
+        if (programs[i]) {
+            os << "Program @ " << programs[i] << ":" << endl;
+            const char *prog =
+                (const char *)loadFromByteCodeOffset(t, programs[i]);
+            dumpProgram(os, t, prog);
+        } else {
+            os << "<No Program>" << endl;
+        }
+    }
+
+    os.close();
 }
 
 static
@@ -361,18 +637,15 @@ void dumpComponentInfo(const RoseEngine *t, const string &base) {
     ss << base << "rose_components.txt";
     ofstream fout(ss.str().c_str());
 
-    const char *p = startNfaRegion(t);
-    const char *pe = endNfaRegion(t);
-
     fout << "Index  Offset\tEngine               \tStates S.State Bytes   Notes\n";
 
-    while (p < pe) {
-        const NFA *n = (const NFA *)p;
-        u32 i = n->queueIndex;
+    for (u32 i = 0; i < t->queueCount; i++) {
+        const NfaInfo *nfa_info = getNfaInfoByQueue(t, i);
+        const NFA *n = getNfaByInfo(t, nfa_info);
 
         fout << left << setw(6) << i << " ";
 
-        fout << left << (p - (const char *)t) << "\t"; /* offset */
+        fout << left << ((const char *)n - (const char *)t) << "\t"; /* offset */
 
         fout << left << setw(16) << describe(*n) << "\t";
 
@@ -383,8 +656,6 @@ void dumpComponentInfo(const RoseEngine *t, const string &base) {
         dumpNfaNotes(fout, t, n);
 
         fout << endl;
-
-        p += ROUNDUP_CL(n->length);
     }
 }
 
@@ -424,20 +695,17 @@ void dumpExhaust(const RoseEngine *t, const string &base) {
 
 static
 void dumpNfas(const RoseEngine *t, bool dump_raw, const string &base) {
-    const char *p = startNfaRegion(t);
-    const char *pe = endNfaRegion(t);
-
     dumpExhaust(t, base);
 
-    while (p < pe) {
-        const NFA *n = (const NFA *)p;
-        u32 q = n->queueIndex;
+    for (u32 i = 0; i < t->queueCount; i++) {
+        const NfaInfo *nfa_info = getNfaInfoByQueue(t, i);
+        const NFA *n = getNfaByInfo(t, nfa_info);
 
         stringstream sstxt, ssdot, ssraw;
 
-        sstxt << base << "rose_nfa_" << q << ".txt";
-        ssdot << base << "rose_nfa_" << q << ".dot";
-        ssraw << base << "rose_nfa_" << q << ".raw";
+        sstxt << base << "rose_nfa_" << i << ".txt";
+        ssdot << base << "rose_nfa_" << i << ".dot";
+        ssraw << base << "rose_nfa_" << i << ".raw";
 
         FILE *f;
 
@@ -454,8 +722,6 @@ void dumpNfas(const RoseEngine *t, bool dump_raw, const string &base) {
             fwrite(n, 1, n->length, f);
             fclose(f);
         }
-
-        p += ROUNDUP_CL(n->length);
     }
 }
 
@@ -465,7 +731,7 @@ void dumpRevComponentInfo(const RoseEngine *t, const string &base) {
     ss << base << "som_rev_components.txt";
     ofstream fout(ss.str().c_str());
 
-    fout << "Index  Offset\tEngine               \tStates S.State Bytes   Notes\n";
+    fout << "Index  Offset\tEngine               \tStates S.State Bytes\n";
 
     const char *tp = (const char *)t;
     const u32 *rev_offsets = (const u32 *)(tp + t->somRevOffsetOffset);
@@ -482,17 +748,13 @@ void dumpRevComponentInfo(const RoseEngine *t, const string &base) {
 
         fout << left << setw(6) << n->nPositions << " ";
         fout << left << setw(7) << n->streamStateSize << " ";
-        fout << left << setw(7) << n->length << " ";
-
-        dumpNfaNotes(fout, t, n);
-
+        fout << left << setw(7) << n->length;
         fout << endl;
     }
 }
 
 static
 void dumpRevNfas(const RoseEngine *t, bool dump_raw, const string &base) {
-
     const char *tp = (const char *)t;
     const u32 *rev_offsets = (const u32 *)(tp + t->somRevOffsetOffset);
 
@@ -582,7 +844,6 @@ void roseDumpText(const RoseEngine *t, FILE *f) {
 
     const void *atable = getAnchoredMatcher(t);
     const HWLM *ftable = getFloatingMatcher(t);
-    const sidecar *stable = getSidecarMatcher(t);
     const HWLM *etable = getEodMatcher(t);
     const HWLM *sbtable = getSmallBlockMatcher(t);
 
@@ -609,9 +870,6 @@ void roseDumpText(const RoseEngine *t, FILE *f) {
     if (t->hasSom) {
         fprintf(f, " hasSom");
     }
-    if (t->simpleCallback) {
-        fprintf(f, " simpleCallback");
-    }
     fprintf(f, "\n");
 
     fprintf(f, "dkey count           : %u\n", t->dkeyCount);
@@ -634,28 +892,16 @@ void roseDumpText(const RoseEngine *t, FILE *f) {
     } else {
         fprintf(f, "\n");
     }
-    fprintf(f, " - sidecar matcher   : %u bytes\n",
-            stable ? sidecarSize(stable) : 0);
     fprintf(f, " - eod-anch matcher  : %zu bytes over last %u bytes\n",
             etable ? hwlmSize(etable) : 0, t->ematcherRegionSize);
     fprintf(f, " - small-blk matcher : %zu bytes over %u bytes\n",
             sbtable ? hwlmSize(sbtable) : 0, t->smallBlockDistance);
-    fprintf(f, " - literal table     : %zu bytes\n",
-            t->literalCount * sizeof(RoseLiteral));
-    fprintf(f, " - side table        : %zu bytes\n",
-            t->sideCount * sizeof(RoseSide));
-    fprintf(f, " - role table        : %zu bytes\n",
-            t->roleCount * sizeof(RoseRole));
-    fprintf(f, " - pred table        : %zu bytes\n",
-            t->predCount * sizeof(RosePred));
     fprintf(f, " - role state table  : %zu bytes\n",
             t->rolesWithStateCount * sizeof(u32));
-    fprintf(f, " - nfa info table    : %u bytes\n",
-            t->rootRoleOffset - t->nfaInfoOffset);
-    fprintf(f, " - root role table   : %zu bytes\n",
-            t->rootRoleCount * sizeof(u32));
+    fprintf(f, " - nfa info table    : %zu bytes\n",
+            t->queueCount * sizeof(NfaInfo));
     fprintf(f, " - lookaround table  : %u bytes\n",
-            t->predOffset - t->lookaroundTableOffset);
+            t->nfaInfoOffset - t->lookaroundTableOffset);
     fprintf(f, " - lookaround reach  : %u bytes\n",
             t->lookaroundTableOffset - t->lookaroundReachOffset);
 
@@ -664,10 +910,7 @@ void roseDumpText(const RoseEngine *t, FILE *f) {
             t->historyRequired);
     fprintf(f, " - exhaustion vector : %u bytes\n", (t->ekeyCount + 7) / 8);
     fprintf(f, " - role state mmbit  : %u bytes\n", t->stateSize);
-    fprintf(f, " - runtime state     : %zu bytes\n", sizeof(RoseRuntimeState));
     fprintf(f, " - floating matcher  : %u bytes\n", t->floatingStreamState);
-    fprintf(f, " - sidecar           : %u bytes\n",
-            stable ? sidecarEnabledSize(stable) : 0U);
     fprintf(f, " - active array      : %u bytes\n",
             mmbit_size(t->activeArrayCount));
     fprintf(f, " - active rose       : %u bytes\n",
@@ -682,62 +925,12 @@ void roseDumpText(const RoseEngine *t, FILE *f) {
     fprintf(f, "\n");
 
     fprintf(f, "initial groups       : 0x%016llx\n", t->initialGroups);
+    fprintf(f, "handled key count    : %u\n", t->handledKeyCount);
     fprintf(f, "\n");
 
-    fprintf(f, "number of literals   : %u\n", t->totalNumLiterals);
-    fprintf(f, " - delayed           : %u\n", t->delay_count);
-    fprintf(f, " - direct report     : %u\n",
-            literalsWithDirectReports(t));
-    fprintf(f, " - that squash group : %u\n",
-            literalsWithProp(t, &RoseLiteral::squashesGroup));
-    fprintf(f, " - need side catchup : %u\n",
-            literalsWithProp(t, &RoseLiteral::requires_side));
-    fprintf(f, " - with benefits     : %u\n", t->nonbenefits_base_id);
-
-    u32 group_weak_end = t->group_weak_end;
-    fprintf(f, " - in groups ::\n");
-    fprintf(f, "   + weak            : %u\n",
-            literalsInGroups(t, 0, group_weak_end));
-    fprintf(f, "   + general         : %u\n",
-            literalsInGroups(t, group_weak_end, sizeof(u64a) * 8));
-    fprintf(f, "number of roles      : %u\n", t->roleCount);
-    fprintf(f, " - with state index  : %u\n", t->rolesWithStateCount);
-    fprintf(f, " - with leftfix nfa  : %u\n",
-            rolesWithFlag(t, ROSE_ROLE_FLAG_ROSE));
-    fprintf(f, " - with suffix nfa   : %u\n", rolesWithSuffixes(t));
-    fprintf(f, " - with lookaround   : %u\n", rolesWithLookaround(t));
-    fprintf(f, " - with reports      : %u\n", rolesWithReports(t));
-    fprintf(f, " - with som reports  : %u\n",
-            rolesWithFlag(t, ROSE_ROLE_FLAG_SOM_REPORT));
-    fprintf(f, " - with eod accepts  : %u\n",
-            rolesWithFlag(t, ROSE_ROLE_FLAG_ACCEPT_EOD));
-    fprintf(f, " - match only at end : %u\n",
-            rolesWithFlag(t, ROSE_ROLE_FLAG_ONLY_AT_END));
-    fprintf(f, "   + anchored        : %u\n", t->anchoredMatches);
-
-    fprintf(f, " - no preds (root)   : %u\n",
-      rolesWithFlag(t, ROSE_ROLE_PRED_NONE));
-    fprintf(f, " - simple preds      : %u\n",
-      rolesWithFlag(t, ROSE_ROLE_PRED_SIMPLE));
-    fprintf(f, " - root preds        : %u\n",
-      rolesWithFlag(t, ROSE_ROLE_PRED_ROOT));
-    fprintf(f, " - 'any' preds       : %u\n",
-      rolesWithFlag(t, ROSE_ROLE_PRED_ANY));
-    fprintf(f, "number of preds      : %u\n", t->predCount);
-    dumpPreds(f, t);
-
-    u32 depth1 = literalsWithDepth(t, 1);
-    u32 depth2 = literalsWithDepth(t, 2);
-    u32 depth3 = literalsWithDepth(t, 3);
-    u32 depth4 = literalsWithDepth(t, 4);
-    u32 depthN = t->literalCount - (depth1 + depth2 + depth3 + depth4);
-
-    fprintf(f, "\nLiteral depths:\n");
-    fprintf(f, "  minimum depth 1    : %u\n", depth1);
-    fprintf(f, "  minimum depth 2    : %u\n", depth2);
-    fprintf(f, "  minimum depth 3    : %u\n", depth3);
-    fprintf(f, "  minimum depth 4    : %u\n", depth4);
-    fprintf(f, "  minimum depth >4   : %u\n", depthN);
+    fprintf(f, "total literal count  : %u\n", t->totalNumLiterals);
+    fprintf(f, "  prog table size    : %u\n", t->literalCount);
+    fprintf(f, "  delayed literals   : %u\n", t->delay_count);
 
     fprintf(f, "\n");
     fprintf(f, "  minWidth                    : %u\n", t->minWidth);
@@ -745,8 +938,6 @@ void roseDumpText(const RoseEngine *t, FILE *f) {
             t->minWidthExcludingBoundaries);
     fprintf(f, "  maxBiAnchoredWidth          : %s\n",
             rose_off(t->maxBiAnchoredWidth).str().c_str());
-    fprintf(f, "  maxSafeAnchoredDROffset     : %s\n",
-            rose_off(t->maxSafeAnchoredDROffset).str().c_str());
     fprintf(f, "  minFloatLitMatchOffset      : %s\n",
             rose_off(t->floatingMinLiteralMatchOffset).str().c_str());
     fprintf(f, "  delay_base_id               : %u\n", t->delay_base_id);
@@ -763,12 +954,6 @@ void roseDumpText(const RoseEngine *t, FILE *f) {
         hwlmPrintStats(ftable, f);
     }
 
-    if (stable) {
-        fprintf(f, "\nSidecar literal matcher stats:\n\n");
-        fprintf(f, "    Side Entries : %u\n", t->sideCount);
-        sidecarDump(stable, f);
-    }
-
     if (etable) {
         fprintf(f, "\nEOD-anchored literal matcher stats:\n\n");
         hwlmPrintStats(etable, f);
@@ -789,18 +974,15 @@ void roseDumpText(const RoseEngine *t, FILE *f) {
 
 void roseDumpStructRaw(const RoseEngine *t, FILE *f) {
     fprintf(f, "struct RoseEngine {\n");
-    DUMP_U8(t, hasFloatingDirectReports);
     DUMP_U8(t, noFloatingRoots);
     DUMP_U8(t, requiresEodCheck);
-    DUMP_U8(t, requiresEodSideCatchup);
-    DUMP_U8(t, hasEodEventLiteral);
     DUMP_U8(t, hasOutfixesInSmallBlock);
     DUMP_U8(t, runtimeImpl);
     DUMP_U8(t, mpvTriggeredByLeaf);
     DUMP_U8(t, canExhaust);
     DUMP_U8(t, hasSom);
     DUMP_U8(t, somHorizon);
-    DUMP_U8(t, simpleCallback);
+    DUMP_U8(t, needsCatchup);
     DUMP_U32(t, mode);
     DUMP_U32(t, historyRequired);
     DUMP_U32(t, ekeyCount);
@@ -816,35 +998,29 @@ void roseDumpStructRaw(const RoseEngine *t, FILE *f) {
     DUMP_U32(t, amatcherOffset);
     DUMP_U32(t, ematcherOffset);
     DUMP_U32(t, fmatcherOffset);
-    DUMP_U32(t, smatcherOffset);
     DUMP_U32(t, sbmatcherOffset);
     DUMP_U32(t, amatcherMinWidth);
     DUMP_U32(t, fmatcherMinWidth);
     DUMP_U32(t, eodmatcherMinWidth);
     DUMP_U32(t, amatcherMaxBiAnchoredWidth);
     DUMP_U32(t, fmatcherMaxBiAnchoredWidth);
-    DUMP_U32(t, intReportOffset);
-    DUMP_U32(t, intReportCount);
-    DUMP_U32(t, literalOffset);
+    DUMP_U32(t, litProgramOffset);
+    DUMP_U32(t, litDelayRebuildProgramOffset);
+    DUMP_U32(t, reportProgramOffset);
+    DUMP_U32(t, reportProgramCount);
     DUMP_U32(t, literalCount);
-    DUMP_U32(t, sideOffset);
-    DUMP_U32(t, sideCount);
-    DUMP_U32(t, multidirectOffset);
     DUMP_U32(t, activeArrayCount);
     DUMP_U32(t, activeLeftCount);
     DUMP_U32(t, queueCount);
-    DUMP_U32(t, roleOffset);
-    DUMP_U32(t, roleCount);
-    DUMP_U32(t, predOffset);
-    DUMP_U32(t, predCount);
-    DUMP_U32(t, rootRoleOffset);
-    DUMP_U32(t, rootRoleCount);
+    DUMP_U32(t, handledKeyCount);
     DUMP_U32(t, leftOffset);
     DUMP_U32(t, roseCount);
     DUMP_U32(t, lookaroundTableOffset);
     DUMP_U32(t, lookaroundReachOffset);
+    DUMP_U32(t, eodProgramOffset);
+    DUMP_U32(t, eodIterProgramOffset);
     DUMP_U32(t, eodIterOffset);
-    DUMP_U32(t, eodIterMapOffset);
+    DUMP_U32(t, eodNfaIterOffset);
     DUMP_U32(t, lastByteHistoryIterOffset);
     DUMP_U32(t, minWidth);
     DUMP_U32(t, minWidthExcludingBoundaries);
@@ -854,26 +1030,18 @@ void roseDumpStructRaw(const RoseEngine *t, FILE *f) {
     DUMP_U32(t, floatingDistance);
     DUMP_U32(t, floatingMinDistance);
     DUMP_U32(t, smallBlockDistance);
-    DUMP_U32(t, maxSafeAnchoredDROffset);
     DUMP_U32(t, floatingMinLiteralMatchOffset);
     DUMP_U32(t, nfaInfoOffset);
-    DUMP_U32(t, anchoredReportMapOffset);
-    DUMP_U32(t, anchoredReportInverseMapOffset);
     DUMP_U64(t, initialGroups);
     DUMP_U32(t, size);
-    DUMP_U32(t, anchoredMatches);
     DUMP_U32(t, delay_count);
-    DUMP_U32(t, delay_slot_size);
     DUMP_U32(t, delay_base_id);
     DUMP_U32(t, anchored_count);
     DUMP_U32(t, anchored_base_id);
-    DUMP_U32(t, nonbenefits_base_id);
     DUMP_U32(t, maxFloatingDelayedMatch);
     DUMP_U32(t, delayRebuildLength);
     DUMP_U32(t, stateOffsets.history);
     DUMP_U32(t, stateOffsets.exhausted);
-    DUMP_U32(t, stateOffsets.sidecar);
-    DUMP_U32(t, stateOffsets.sidecar_size);
     DUMP_U32(t, stateOffsets.activeLeafArray);
     DUMP_U32(t, stateOffsets.activeLeftArray);
     DUMP_U32(t, stateOffsets.activeLeftArray_size);
@@ -891,7 +1059,6 @@ void roseDumpStructRaw(const RoseEngine *t, FILE *f) {
     DUMP_U32(t, boundary.reportZeroEodOffset);
     DUMP_U32(t, totalNumLiterals);
     DUMP_U32(t, asize);
-    DUMP_U32(t, initSideEnableOffset);
     DUMP_U32(t, outfixBeginQueue);
     DUMP_U32(t, outfixEndQueue);
     DUMP_U32(t, leftfixBeginQueue);
@@ -899,73 +1066,24 @@ void roseDumpStructRaw(const RoseEngine *t, FILE *f) {
     DUMP_U32(t, rosePrefixCount);
     DUMP_U32(t, activeLeftIterOffset);
     DUMP_U32(t, ematcherRegionSize);
-    DUMP_U32(t, literalBenefitsOffsets);
     DUMP_U32(t, somRevCount);
     DUMP_U32(t, somRevOffsetOffset);
-    DUMP_U32(t, nfaRegionBegin);
-    DUMP_U32(t, nfaRegionEnd);
     DUMP_U32(t, group_weak_end);
     DUMP_U32(t, floatingStreamState);
-    DUMP_U32(t, eodLiteralId);
     fprintf(f, "}\n");
     fprintf(f, "sizeof(RoseEngine) = %zu\n", sizeof(RoseEngine));
 }
 
-static
-void roseDumpPredStructRaw(const RoseEngine *t, FILE *f) {
-    u32 pred_count = 0;
-    const RosePred *pred_table = getPredTable(t, &pred_count);
-    fprintf(f, "pred_count = %u\n", pred_count);
-    if (!pred_table) {
-        return;
-    }
-
-    for (const RosePred *p = pred_table; p < pred_table + pred_count; p++) {
-        fprintf(f, "pred[%zu] = {\n", p - pred_table);
-        DUMP_U32(p, role);
-        DUMP_U32(p, minBound);
-        DUMP_U32(p, maxBound);
-        DUMP_U8(p, historyCheck);
-        fprintf(f, "}\n");
-    }
-}
-
-static
-void roseDumpRoleStructRaw(const RoseEngine *t, FILE *f) {
-    const RoseRole *tr = getRoleTable(t);
-    const RoseRole *tr_end = tr + t->roleCount;
-    fprintf(f, "role_count = %zd\n", tr_end - tr);
-    if (!tr) {
-        return;
-    }
-
-    for (const RoseRole *p = tr; p < tr_end; p++) {
-        fprintf(f, "role[%zu] = {\n", p - tr);
-        DUMP_U32(p, flags);
-        DUMP_U32(p, predOffset);
-        DUMP_U64(p, groups);
-        DUMP_U32(p, reportId);
-        DUMP_U32(p, stateIndex);
-        DUMP_U32(p, suffixEvent);
-        DUMP_U8(p, depth);
-        DUMP_U32(p, suffixOffset);
-        DUMP_U32(p, leftfixReport);
-        DUMP_U32(p, leftfixLag);
-        DUMP_U32(p, leftfixQueue);
-        DUMP_U32(p, sidecarEnableOffset);
-        DUMP_U32(p, somAdjust);
-        DUMP_U32(p, lookaroundIndex);
-        DUMP_U32(p, lookaroundCount);
-        fprintf(f, "}\n");
-    }
-}
-
-void roseDumpComponents(const RoseEngine *t, bool dump_raw, const string &base) {
+void roseDumpComponents(const RoseEngine *t, bool dump_raw,
+                        const string &base) {
     dumpComponentInfo(t, base);
     dumpNfas(t, dump_raw, base);
     dumpAnchored(t, base);
     dumpRevComponentInfo(t, base);
     dumpRevNfas(t, dump_raw, base);
+    dumpRoseLitPrograms(t, base + "/rose_lit_programs.txt");
+    dumpRoseEodPrograms(t, base + "/rose_eod_programs.txt");
+    dumpRoseReportPrograms(t, base + "/rose_report_programs.txt");
 }
 
 void roseDumpInternals(const RoseEngine *t, const string &base) {
@@ -976,7 +1094,6 @@ void roseDumpInternals(const RoseEngine *t, const string &base) {
 
     const void *atable = getAnchoredMatcher(t);
     const HWLM *ftable = getFloatingMatcher(t);
-    const sidecar *stable = getSidecarMatcher(t);
     const HWLM *etable = getEodMatcher(t);
 
     if (atable) {
@@ -995,14 +1112,6 @@ void roseDumpInternals(const RoseEngine *t, const string &base) {
         }
     }
 
-    if (stable) {
-        FILE *f = fopen((base + "/sidecar.raw").c_str(), "w");
-        if (f) {
-            fwrite(stable, 1, sidecarSize(stable), f);
-            fclose(f);
-        }
-    }
-
     if (etable) {
         FILE *f = fopen((base + "/eod.raw").c_str(), "w");
         if (f) {
@@ -1020,14 +1129,6 @@ void roseDumpInternals(const RoseEngine *t, const string &base) {
     roseDumpStructRaw(t, f);
     fclose(f);
 
-    f = fopen((base + "/rose_preds.txt").c_str(), "w");
-    roseDumpPredStructRaw(t, f);
-    fclose(f);
-
-    f = fopen((base + "/rose_roles.txt").c_str(), "w");
-    roseDumpRoleStructRaw(t, f);
-    fclose(f);
-
     roseDumpComponents(t, true, base);
 }
 
diff --git a/src/rose/rose_graph.h b/src/rose/rose_graph.h
index 1b893a88..b0ac8d11 100644
--- a/src/rose/rose_graph.h
+++ b/src/rose/rose_graph.h
@@ -39,7 +39,7 @@
 
 #include "ue2common.h"
 #include "rose_build.h"
-#include "rose_internal.h" /* role history, etc */
+#include "rose_internal.h"
 #include "nfa/nfa_internal.h" // for MO_INVALID_IDX
 #include "util/charreach.h"
 #include "util/depth.h"
@@ -65,6 +65,14 @@ enum rose_literal_table {
     ROSE_EVENT                 //!< "literal-like" events, such as EOD
 };
 
+/** \brief Edge history types. */
+enum RoseRoleHistory {
+    ROSE_ROLE_HISTORY_NONE,      //!< no special history
+    ROSE_ROLE_HISTORY_ANCH,      //!< previous role is at a fixed offset
+    ROSE_ROLE_HISTORY_LAST_BYTE, //!< previous role can only match at EOD
+    ROSE_ROLE_HISTORY_INVALID    //!< history not yet assigned
+};
+
 #include "util/order_check.h"
 
 /** \brief Provides information about the (pre|in)fix engine to the left of a
@@ -140,15 +148,9 @@ struct RoseVertexProps {
     /** \brief Report IDs to fire. */
     flat_set<ReportID> reports;
 
-    /** \brief Role ID for this vertex. These are what end up in the bytecode. */
-    u32 role = ~u32{0};
-
     /** \brief Bitmask of groups that this role sets. */
     rose_group groups = 0;
 
-    /** \brief Characters that escape and squash this role. */
-    CharReach escapes;
-
     /** \brief Minimum role (end of literal) offset depth in bytes. */
     u32 min_offset = ~u32{0};
 
diff --git a/src/rose/rose_in_graph.h b/src/rose/rose_in_graph.h
index 15be6b0f..2c00a418 100644
--- a/src/rose/rose_in_graph.h
+++ b/src/rose/rose_in_graph.h
@@ -168,12 +168,6 @@ struct RoseInEdgeProps {
     std::shared_ptr<raw_som_dfa> haig;
 
     u32 graph_lag;
-
-    /** \brief Escape characters, can be used instead of graph.
-     *
-     * currently must not intersect with succ literal and must be a literal -
-     * literal edge, TODO: handle */
-    CharReach escapes;
 };
 
 typedef boost::adjacency_list<boost::listS, boost::listS, boost::bidirectionalS,
diff --git a/src/rose/rose_internal.h b/src/rose/rose_internal.h
index 1f4fc93a..bbe0b1b6 100644
--- a/src/rose/rose_internal.h
+++ b/src/rose/rose_internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -48,67 +48,11 @@ typedef u64a rose_group;
 #define MAX_DELAY                   (DELAY_SLOT_COUNT - 1)
 #define DELAY_MASK                  (DELAY_SLOT_COUNT - 1)
 
-#define DELAY_FLOAT_DIRTY      (1U << 7) /* delay literal matched in history */
-
-// Direct report stuff
-#define LITERAL_DR_FLAG   (1U << 31)
-#define LITERAL_MDR_FLAG  ((1U << 30) | (1U << 31))
-
-/** \brief True if literal is either a direct report or a multi-direct report.
- * */
-static really_inline
-u32 isLiteralDR(u32 id) {
-    return id & LITERAL_DR_FLAG;
-}
-
-static really_inline
-u32 isLiteralMDR(u32 id) {
-    return (id & LITERAL_MDR_FLAG) == LITERAL_MDR_FLAG;
-}
-
-static really_inline
-ReportID literalToReport(u32 id) {
-    assert(id & LITERAL_DR_FLAG);
-    assert(!(id & (LITERAL_MDR_FLAG ^ LITERAL_DR_FLAG)));
-    return id & ~LITERAL_DR_FLAG;
-}
-
-// Structure representing a literal. Each literal may have many roles.
-struct RoseLiteral {
-    u32 rootRoleOffset; /**< If rootRoleCount == 1, this is an offset relative
-                         * to the rose engine to the root role associated with
-                         * the literal.
-                         * If rootRoleCount > 1, this is the first index into
-                         * the rootRoleTable indicating the root roles.
-                         */
-    u32 rootRoleCount; // number of root roles
-    u32 iterOffset; // offset of sparse iterator, relative to rose
-    u32 iterMapOffset; // offset of the iter mapping table, relative to rose
-    rose_group groups; // bitset of groups that cause this literal to fire.
-    u8 minDepth; // the minimum of this literal's roles' depths (for depths > 1)
-    u8 squashesGroup; /**< literal switches off its group behind it if it sets a
-                       * role */
-    u8 requires_side; // need to catch up sidecar for this literal
-    u32 delay_mask; /**< bit set indicates that the literal inserts a delayed
-                     * match at the given offset */
-    u32 delayIdsOffset; // offset to array of ids to poke in the delay structure
-};
-
-/* properties for sidecar entries, yay */
-struct RoseSide {
-    u32 squashIterOffset; // offset of the squash sparse iterator, rose relative
-    rose_group squashGroupMask; // squash literal squash masks
-};
-
 /* Allocation of Rose literal ids
  *
  * The rose literal id space is segmented:
  *
  * ---- 0
- * |  | Normal undelayed literals in the e, or f tables which require a
- * |  | manual benefits confirm on match [a table never requires benefits]
- * |  |
- * ---- nonbenefits_base_id
  * |  | 'Normal' undelayed literals in either e or f tables
  * |  |
  * |  |
@@ -120,31 +64,19 @@ struct RoseSide {
  * |  | Delayed version of normal literals
  * |  |
  * ---- literalCount
- * ...
- * ...
- * ...
- * ---- LITERAL_DR_FLAG
- * |  | Direct Report literals: immediately raise an internal report with id
- * |  | given by (lit_id & ~LITERAL_DR_FLAG). Raised by a or f tables (or e??).
- * |  | No RoseLiteral structure
- * |  |
- * |  |
- * ----
- *
- * Note: sidecar 'literals' are in a complete separate space
  */
 
 /* Rose Literal Sources
  *
- * Rose currently gets events (mainly roseProcessMatch calls) from 8 sources:
+ * Rose currently gets events (mainly roseProcessMatch calls) from a number of
+ * sources:
  * 1) The floating table
  * 2) The anchored table
  * 3) Delayed literals
- * 4) Sidecar literal matcher
- * 5) suffixes NFAs
- * 6) masksv2 (literals with benefits)
- * 7) End anchored table
- * 8) prefix / infix nfas
+ * 4) Suffix NFAs
+ * 5) Literal masks
+ * 5) End anchored table
+ * 6) Prefix / Infix nfas
  *
  * Care is required to ensure that events appear to come into Rose in order
  * (or sufficiently ordered for Rose to cope). Generally the progress of the
@@ -162,19 +94,12 @@ struct RoseSide {
  * Delayed literal ordering is handled by delivering any pending delayed
  * literals before processing any floating match.
  *
- * Sidecar:
- * The sidecar matcher is unique in that it does not return match
- * location information. Sidecar literals are escapes between two normal
- * roles. The sidecar matcher is caught up to the floating matcher
- * before any possible predecessor role, any possible successor role, and
- * at stream boundaries^3.
- *
  * Suffix:
  * Suffixes are always pure terminal roles. Prior to raising a match^2, pending
  * NFA queues are run to the current point (floating or delayed literal) as
  * appropriate.
  *
- * Maskv2:
+ * Literal Masks:
  * These are triggered from either floating literals or delayed literals and
  * inspect the data behind them. Matches are raised at the same location as the
  * trigger literal so there are no ordering issues. Masks are always pure
@@ -202,15 +127,6 @@ struct RoseSide {
  *    terminals.
  */
 
-// We have different types of role history storage.
-enum RoseRoleHistory {
-    ROSE_ROLE_HISTORY_NONE, // I'm sorry, I don't recall.
-    ROSE_ROLE_HISTORY_ANCH, // used when previous role is at a fixed offset
-    ROSE_ROLE_HISTORY_LAST_BYTE, /* used when previous role can only match at the
-                                  * last byte of a stream */
-    ROSE_ROLE_HISTORY_INVALID // history not yet assigned
-};
-
 struct RoseCountingMiracle {
     char shufti; /** 1: count shufti class; 0: count a single character */
     u8 count; /** minimum number of occurrences for the counting
@@ -233,13 +149,6 @@ struct LeftNfaInfo {
     rose_group squash_mask; /* & mask applied when rose nfa dies */
 };
 
-// A list of these is used to trigger prefix/infix roses.
-struct RoseTrigger {
-    u32 queue; // queue index of leftfix
-    u32 event; // queue event, from MQE_*
-    u8 cancel_prev_top;
-};
-
 struct NfaInfo {
     u32 nfaOffset;
     u32 stateOffset;
@@ -255,43 +164,6 @@ struct NfaInfo {
              * matches */
 };
 
-#define ROSE_ROLE_FLAG_ANCHOR_TABLE  (1U << 0)  /**< role is triggered from
-                                                 * anchored table */
-#define ROSE_ROLE_FLAG_ACCEPT_EOD    (1U << 2)  /**< "fake" role, fires callback
-                                                 * at EOD */
-#define ROSE_ROLE_FLAG_ONLY_AT_END   (1U << 3)  /**< role can only be switched on
-                                                 * at end of block */
-#define ROSE_ROLE_FLAG_PRED_OF_EOD   (1U << 4)  /**< eod is a successor literal
-                                                 * of the role */
-#define ROSE_ROLE_FLAG_EOD_TABLE     (1U << 5)  /**< role is triggered from eod
-                                                 * table */
-#define ROSE_ROLE_FLAG_ROSE          (1U << 6)  /**< rose style prefix nfa for
-                                                 * role */
-#define ROSE_ROLE_FLAG_SOM_REPORT    (1U << 7)  /**< report id is only used to
-                                                 * manipulate som */
-#define ROSE_ROLE_FLAG_REPORT_START  (1U << 8)  /**< som som som som */
-#define ROSE_ROLE_FLAG_CHAIN_REPORT  (1U << 9)  /**< report id is only used to
-                                                 * start an outfix engine */
-#define ROSE_ROLE_FLAG_SOM_ADJUST    (1U << 10) /**< som value to use is offset
-                                                 * from match end location */
-#define ROSE_ROLE_FLAG_SOM_ROSEFIX   (1U << 11) /**< som value to use is provided
-                                                 * by prefix/infix */
-
-/* We allow different types of role-predecessor relationships. These are stored
- * in with the flags */
-#define ROSE_ROLE_PRED_NONE         (1U << 20) /**< the only pred is the root,
-                                                * [0, inf] bounds */
-#define ROSE_ROLE_PRED_SIMPLE       (1U << 21) /**< single [0,inf] pred, no
-                                                * offset tracking */
-#define ROSE_ROLE_PRED_ROOT         (1U << 22) /**< pred is root or anchored
-                                                * root, and we have bounds */
-#define ROSE_ROLE_PRED_ANY          (1U << 23) /**< any of our preds can match */
-
-#define ROSE_ROLE_PRED_CLEAR_MASK (~(ROSE_ROLE_PRED_NONE       \
-                                    | ROSE_ROLE_PRED_SIMPLE    \
-                                    | ROSE_ROLE_PRED_ROOT      \
-                                    | ROSE_ROLE_PRED_ANY))
-
 #define MAX_STORED_LEFTFIX_LAG 127 /* max leftfix lag that we can store in one
                                     * whole byte (OWB) (streaming only). Other
                                     * values in OWB are reserved for zombie
@@ -299,56 +171,6 @@ struct NfaInfo {
 #define OWB_ZOMBIE_ALWAYS_YES 128 /* nfa will always answer yes to any rose
                                    * prefix checks */
 
-// Structure representing a literal role.
-struct RoseRole {
-    u32 flags;
-    u32 predOffset; // either offset of pred sparse iterator, or
-                    // (for ROSE_ROLE_PRED_ROOT) index of single RosePred.
-    rose_group groups; /**< groups to enable when role is set (groups of succ
-                        *  literals) */
-    ReportID reportId; // report ID, or MO_INVALID_IDX
-    u32 stateIndex; /**< index into state multibit, or MMB_INVALID. Roles do not
-                     * require a state bit if they are terminal */
-    u32 suffixEvent; // queue event, from MQE_
-    u8 depth; /**< depth of this vertex from root in the tree, or 255 if greater.
-               */
-    u32 suffixOffset; /**< suffix nfa: 0 if no suffix associated with the role,
-                       *  relative to base of the rose. */
-    ReportID leftfixReport; // (pre|in)fix report to check, or MO_INVALID_IDX.
-    u32 leftfixLag; /**< distance behind match where we need to check the
-                     * leftfix engine status */
-    u32 leftfixQueue; /**< queue index of the prefix/infix before role */
-    u32 infixTriggerOffset; /* offset to list of infix roses to trigger */
-    u32 sidecarEnableOffset; /**< offset to list of sidecar literals to enable
-                              */
-    u32 somAdjust; /**< som for the role is offset from end match offset */
-
-    u32 lookaroundIndex; /**< index of lookaround offset/reach in table, or
-                          * MO_INVALID_IDX. */
-    u32 lookaroundCount; /**< number of lookaround entries. */
-};
-
-// Structure representing a predecessor relationship
-struct RosePred {
-    u32 role; // index of predecessor role
-    u32 minBound; // min bound on distance from pred (_ANCH ->absolute offset)
-    u32 maxBound; /* max bound on distance from pred, or ROSE_BOUND_INF
-                   * (_ANCH -> absolute offset ) */
-    u8 historyCheck; // from enum RoseRoleHistory
-};
-
-// Structure mapping between the dense index produced by the literal sparse
-// iterator and a list of roles.
-struct RoseIterMapping {
-    u32 offset; // offset into iter role table
-    u32 count; // number of roles
-};
-
-struct RoseIterRole {
-    u32 role;
-    u32 pred;
-};
-
 /**
  * \brief Rose state offsets.
  *
@@ -357,7 +179,7 @@ struct RoseIterRole {
  *
  * State not covered by this structure includes:
  *
- * -# the RoseRuntimeState structure
+ * -# the first byte, containing the status bitmask
  * -# the role state multibit
  */
 struct RoseStateOffsets {
@@ -374,12 +196,6 @@ struct RoseStateOffsets {
      * reports with that ekey should not be delivered to the user. */
     u32 exhausted;
 
-    /** Sidecar state. */
-    u32 sidecar;
-
-    /** Size of sidecar state, in bytes. */
-    u32 sidecar_size;
-
     /** Multibit for active suffix/outfix engines. */
     u32 activeLeafArray;
 
@@ -419,14 +235,17 @@ struct RoseStateOffsets {
 };
 
 struct RoseBoundaryReports {
-    u32 reportEodOffset; /**< 0 if no reports lits, otherwise offset of
-                          * MO_INVALID_IDX terminated list to report at EOD */
-    u32 reportZeroOffset; /**< 0 if no reports lits, otherwise offset of
-                           * MO_INVALID_IDX terminated list to report at offset
-                           * 0 */
-    u32 reportZeroEodOffset; /**< 0 if no reports lits, otherwise offset of
-                              * MO_INVALID_IDX terminated list to report if eod
-                              * is at offset 0. Superset of other lists. */
+    /** \brief 0 if no reports list, otherwise offset of program to run to
+     * deliver reports at EOD. */
+    u32 reportEodOffset;
+
+    /** \brief 0 if no reports list, otherwise offset of program to run to
+     * deliver reports at offset 0. */
+    u32 reportZeroOffset;
+
+    /** \brief 0 if no reports list, otherwise offset of program to run to
+     * deliver reports if EOD is at offset 0. Superset of other programs. */
+    u32 reportZeroEodOffset;
 };
 
 /* NFA Queue Assignment
@@ -456,33 +275,27 @@ struct RoseBoundaryReports {
 #define ROSE_RUNTIME_PURE_LITERAL  1
 #define ROSE_RUNTIME_SINGLE_OUTFIX 2
 
-// Runtime structure header for Rose.
-// In memory, we follow this with:
-//   1a. anchored 'literal' matcher table
-//   1b. floating literal matcher table
-//   1c. sidecar 'literal' matcher table
-//   1d. eod-anchored literal matcher table
-//   1e. small block table
-//   2. array of RoseLiteral (literalCount entries)
-//   3. array of RoseRole (roleCount entries)
-//   4. array of RosePred (predCount entries)
-//   8. array of NFA offsets, one per queue
-//   9. array of state offsets, one per queue (+)
-//  10. array of role ids for the set of all root roles
-//  12. multi-direct report array
-/*
+/**
+ * \brief Runtime structure header for Rose.
+ *
+ * Runtime structure header for Rose.
+ * In memory, we follow this with:
+ *   -# the "engine blob"
+ *   -# anchored 'literal' matcher table
+ *   -# floating literal matcher table
+ *   -# eod-anchored literal matcher table
+ *   -# small block table
+ *   -# array of NFA offsets, one per queue
+ *   -# array of state offsets, one per queue (+)
+ *
  *  (+) stateOffset array note: Offsets in the array are either into the stream
  *  state (normal case) or into the tstate region of scratch (for transient rose
  *  nfas). Rose nfa info table can distinguish the cases.
  */
 struct RoseEngine {
-    u8  hasFloatingDirectReports; // has at least one floating direct report literal
     u8  noFloatingRoots; /* only need to run the anchored table if something
                           * matched in the anchored table */
     u8  requiresEodCheck; /* stuff happens at eod time */
-    u8  requiresEodSideCatchup; /* we need to do a sidecar catchup before eod
-                                 * checks */
-    u8  hasEodEventLiteral; // fires a ROSE_EVENT literal at eod time.
     u8  hasOutfixesInSmallBlock; /**< has at least one outfix that must run even
                                     in small block scans. */
     u8  runtimeImpl; /**< can we just run the floating table or a single outfix?
@@ -492,8 +305,7 @@ struct RoseEngine {
     u8  hasSom; /**< has at least one pattern which tracks SOM. */
     u8  somHorizon; /**< width in bytes of SOM offset storage (governed by
                         SOM precision) */
-    u8  simpleCallback; /**< has only external reports with no bounds checks,
-                             plus no exhaustion keys */
+    u8 needsCatchup; /** catch up needs to be run on every report. */
     u32 mode; /**< scanning mode, one of HS_MODE_{BLOCK,STREAM,VECTORED} */
     u32 historyRequired; /**< max amount of history required for streaming */
     u32 ekeyCount; /**< number of exhaustion keys */
@@ -513,7 +325,6 @@ struct RoseEngine {
     u32 amatcherOffset; // offset of the anchored literal matcher (bytes)
     u32 ematcherOffset; // offset of the eod-anchored literal matcher (bytes)
     u32 fmatcherOffset; // offset of the floating literal matcher (bytes)
-    u32 smatcherOffset; // offset of the sidecar literal matcher (bytes)
     u32 sbmatcherOffset; // offset of the small-block literal matcher (bytes)
     u32 amatcherMinWidth; /**< minimum number of bytes required for a pattern
                            * involved with the anchored table to produce a full
@@ -530,23 +341,34 @@ struct RoseEngine {
     u32 fmatcherMaxBiAnchoredWidth; /**< maximum number of bytes that can still
                                      * produce a match for a pattern involved
                                      * with the anchored table. */
-    u32 intReportOffset; /**< offset of array of internal_report structures */
-    u32 intReportCount; /**< number of internal_report structures */
-    u32 literalOffset; // offset of RoseLiteral array (bytes)
-    u32 literalCount; // number of RoseLiteral entries [NOT number of literals]
-    u32 sideOffset; /**< offset of RoseSide array (bytes), indexed by
-                     *sidecar ids */
-    u32 sideCount; /**< number of RoseSide entries */
-    u32 multidirectOffset; /**< offset of multi-direct report list. */
+    /** \brief Offset of u32 array of program offsets for literals. */
+    u32 litProgramOffset;
+
+    /** \brief Offset of u32 array of delay rebuild program offsets for
+     * literals. */
+    u32 litDelayRebuildProgramOffset;
+
+    /** \brief Offset of u32 array of program offsets for internal reports. */
+    u32 reportProgramOffset;
+
+    /** \brief Number of programs for internal reports. */
+    u32 reportProgramCount;
+
+    /**
+     * \brief Number of entries in the arrays pointed to by litProgramOffset,
+     * litDelayRebuildProgramOffset.
+     *
+     * Note: NOT the total number of literals.
+     */
+    u32 literalCount;
+
     u32 activeArrayCount; //number of nfas tracked in the active array
     u32 activeLeftCount; //number of nfas tracked in the active rose array
     u32 queueCount;      /**< number of nfa queues */
-    u32 roleOffset; // offset of RoseRole array (bytes)
-    u32 roleCount; // number of RoseRole entries
-    u32 predOffset; // offset of RosePred array (bytes)
-    u32 predCount; // number of RosePred entries
-    u32 rootRoleOffset;
-    u32 rootRoleCount;
+
+    /** \brief Number of keys used by CHECK_SET_HANDLED instructions in role
+     * programs. Used to size the handled_roles fatbit in scratch. */
+    u32 handledKeyCount;
 
     u32 leftOffset;
     u32 roseCount;
@@ -554,8 +376,12 @@ struct RoseEngine {
     u32 lookaroundReachOffset; /**< base of lookaround reach bitvectors (32
                                 * bytes each) */
 
-    u32 eodIterOffset; // or 0 if no eod iterator
-    u32 eodIterMapOffset;
+    u32 eodProgramOffset; //!< Unconditional EOD program, otherwise 0.
+    u32 eodIterProgramOffset; // or 0 if no eod iterator program
+    u32 eodIterOffset; // offset to EOD sparse iter or 0 if none
+
+    /** \brief Offset to sparse iter over outfix/suffix NFAs that accept EOD. */
+    u32 eodNfaIterOffset;
 
     u32 lastByteHistoryIterOffset; // if non-zero
 
@@ -575,27 +401,18 @@ struct RoseEngine {
     u32 floatingMinDistance; /* start of region to run floating table over */
     u32 smallBlockDistance; /* end of region to run the floating table over
                                ROSE_BOUND_INF if not bounded */
-    u32 maxSafeAnchoredDROffset; /* the maximum offset that we can safely raise
-                                  * a direct report from the anchored table
-                                  * without delaying it */
     u32 floatingMinLiteralMatchOffset; /* the minimum offset that we can get a
                                         * 'valid' match from the floating
                                         * table */
     u32 nfaInfoOffset; /* offset to the nfa info offset array */
-    u32 anchoredReportMapOffset; /* am_log index --> reportid */
-    u32 anchoredReportInverseMapOffset; /*  reportid --> am_log index */
     rose_group initialGroups;
     u32 size; // (bytes)
-    u32 anchoredMatches; /* number of anchored roles generating matches */
     u32 delay_count; /* number of delayed literal ids. */
-    u32 delay_slot_size; /* size of delay slot mmbit. */
     u32 delay_base_id; /* literal id of the first delayed literal.
                         * delayed literal ids are contiguous */
     u32 anchored_count; /* number of anchored literal ids */
     u32 anchored_base_id; /* literal id of the first literal in the A table.
                            * anchored literal ids are contiguous */
-    u32 nonbenefits_base_id; /* first literal id without benefit conf.
-                              * contiguous, blah, blah */
     u32 maxFloatingDelayedMatch; /* max offset that a delayed literal can
                                   * usefully be reported */
     u32 delayRebuildLength; /* length of the history region which needs to be
@@ -605,7 +422,6 @@ struct RoseEngine {
     struct RoseBoundaryReports boundary;
     u32 totalNumLiterals; /* total number of literals including dr */
     u32 asize; /* size of the atable */
-    u32 initSideEnableOffset; /* sidecar literals enabled initially */
     u32 outfixBeginQueue; /* first outfix queue */
     u32 outfixEndQueue; /* one past the last outfix queue */
     u32 leftfixBeginQueue; /* first prefix/infix queue */
@@ -613,45 +429,14 @@ struct RoseEngine {
     u32 rosePrefixCount; /* number of rose prefixes */
     u32 activeLeftIterOffset; /* mmbit_sparse_iter over non-transient roses */
     u32 ematcherRegionSize; /* max region size to pass to ematcher */
-    u32 literalBenefitsOffsets; /* offset to array of benefits indexed by lit
-                                   id */
     u32 somRevCount; /**< number of som reverse nfas */
     u32 somRevOffsetOffset; /**< offset to array of offsets to som rev nfas */
-    u32 nfaRegionBegin; /* start of the nfa region, debugging only */
-    u32 nfaRegionEnd; /* end of the nfa region, debugging only */
     u32 group_weak_end; /* end of weak groups, debugging only */
     u32 floatingStreamState; // size in bytes
-    u32 eodLiteralId; // literal ID for eod ROSE_EVENT if used, otherwise 0.
 
     struct scatter_full_plan state_init;
 };
 
-struct lit_benefits {
-    union {
-        u64a a64[MAX_MASK2_WIDTH/sizeof(u64a)];
-        u8 a8[MAX_MASK2_WIDTH];
-    } and_mask;
-    union {
-        u64a e64[MAX_MASK2_WIDTH/sizeof(u64a)];
-        u8 e8[MAX_MASK2_WIDTH];
-    } expected;
-};
-
-#if defined(_WIN32)
-#pragma pack(push, 1)
-#endif
-// Rose runtime state
-struct RoseRuntimeState {
-    u8 stored_depth; /* depth at stream boundary */
-    u8 flags; /* high bit true if delay rebuild needed */
-    u8 broken; /* user has requested that we stop matching */
-#if defined(_WIN32)
-};
-#pragma pack(pop)
-#else
-} __attribute__((packed));
-#endif
-
 struct ALIGN_CL_DIRECTIVE anchored_matcher_info {
     u32 next_offset; /* relative to this, 0 for end */
     u32 state_offset; /* relative to anchorState */
@@ -683,17 +468,6 @@ const struct HWLM *getFLiteralMatcher(const struct RoseEngine *t) {
     return (const struct HWLM *)lt;
 }
 
-static really_inline
-const void *getSLiteralMatcher(const struct RoseEngine *t) {
-    if (!t->smatcherOffset) {
-        return NULL;
-    }
-
-    const char *st = (const char *)t + t->smatcherOffset;
-    assert(ISALIGNED_N(st, 8));
-    return st;
-}
-
 static really_inline
 const void *getELiteralMatcher(const struct RoseEngine *t) {
     if (!t->ematcherOffset) {
@@ -716,38 +490,6 @@ const void *getSBLiteralMatcher(const struct RoseEngine *t) {
     return matcher;
 }
 
-static really_inline
-const struct RoseLiteral *getLiteralTable(const struct RoseEngine *t) {
-    const struct RoseLiteral *tl
-        = (const struct RoseLiteral *)((const char *)t + t->literalOffset);
-    assert(ISALIGNED_N(tl, 4));
-    return tl;
-}
-
-static really_inline
-const struct RoseSide *getSideEntryTable(const struct RoseEngine *t) {
-    const struct RoseSide *rs
-        = (const struct RoseSide *)((const char *)t + t->sideOffset);
-    assert(ISALIGNED(rs));
-    return rs;
-}
-
-static really_inline
-const struct RoseRole *getRoleTable(const struct RoseEngine *t) {
-    const struct RoseRole *r
-        = (const struct RoseRole *)((const char *)t + t->roleOffset);
-    assert(ISALIGNED_N(r, 4));
-    return r;
-}
-
-static really_inline
-const struct RosePred *getPredTable(const struct RoseEngine *t) {
-    const struct RosePred *p
-        = (const struct RosePred *)((const char *)t + t->predOffset);
-    assert(ISALIGNED_N(p, 4));
-    return p;
-}
-
 static really_inline
 const struct LeftNfaInfo *getLeftTable(const struct RoseEngine *t) {
     const struct LeftNfaInfo *r
@@ -767,20 +509,6 @@ const struct mmbit_sparse_iter *getActiveLeftIter(const struct RoseEngine *t) {
     return it;
 }
 
-static really_inline
-const u32 *getRootRoleTable(const struct RoseEngine *t) {
-    const u32 *r = (const u32 *)((const char *)t + t->rootRoleOffset);
-    assert(ISALIGNED_N(r, 4));
-    return r;
-}
-
-static really_inline
-const struct lit_benefits *getLiteralBenefitsTable(
-                                              const struct RoseEngine *t) {
-    return (const struct lit_benefits *)
-        ((const char *)t + t->literalBenefitsOffsets);
-}
-
 static really_inline
 const struct NfaInfo *getNfaInfoByQueue(const struct RoseEngine *t, u32 qi) {
     const struct NfaInfo *infos
diff --git a/src/rose/rose_program.h b/src/rose/rose_program.h
new file mode 100644
index 00000000..01572dbd
--- /dev/null
+++ b/src/rose/rose_program.h
@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) 2015-2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** \file
+ * \brief Rose data structures to do with role programs.
+ */
+
+#ifndef ROSE_ROSE_PROGRAM_H
+#define ROSE_ROSE_PROGRAM_H
+
+#include "som/som_operation.h"
+#include "rose_internal.h"
+#include "ue2common.h"
+
+/** \brief Minimum alignment for each instruction in memory. */
+#define ROSE_INSTR_MIN_ALIGN 8U
+
+/** \brief Role program instruction opcodes. */
+enum RoseInstructionCode {
+    ROSE_INSTR_ANCHORED_DELAY,    //!< Delay until after anchored matcher.
+    ROSE_INSTR_CHECK_LIT_MASK,    //!< Check and/cmp mask.
+    ROSE_INSTR_CHECK_LIT_EARLY,   //!< Skip matches before floating min offset.
+    ROSE_INSTR_CHECK_GROUPS,      //!< Check that literal groups are on.
+    ROSE_INSTR_CHECK_ONLY_EOD,    //!< Role matches only at EOD.
+    ROSE_INSTR_CHECK_BOUNDS,      //!< Bounds on distance from offset 0.
+    ROSE_INSTR_CHECK_NOT_HANDLED, //!< Test & set role in "handled".
+    ROSE_INSTR_CHECK_LOOKAROUND,  //!< Lookaround check.
+    ROSE_INSTR_CHECK_INFIX,       //!< Infix engine must be in accept state.
+    ROSE_INSTR_CHECK_PREFIX,      //!< Prefix engine must be in accept state.
+    ROSE_INSTR_PUSH_DELAYED,      //!< Push delayed literal matches.
+    ROSE_INSTR_CATCH_UP,          //!< Catch up engines, anchored matches.
+    ROSE_INSTR_CATCH_UP_MPV,      //!< Catch up the MPV.
+    ROSE_INSTR_SOM_ADJUST,        //!< Set SOM from a distance to EOM.
+    ROSE_INSTR_SOM_LEFTFIX,       //!< Acquire SOM from a leftfix engine.
+    ROSE_INSTR_SOM_FROM_REPORT,   //!< Acquire SOM from a som_operation.
+    ROSE_INSTR_SOM_ZERO,          //!< Set SOM to zero.
+    ROSE_INSTR_TRIGGER_INFIX,     //!< Trigger an infix engine.
+    ROSE_INSTR_TRIGGER_SUFFIX,    //!< Trigger a suffix engine.
+    ROSE_INSTR_DEDUPE,            //!< Run deduplication for report.
+    ROSE_INSTR_DEDUPE_SOM,        //!< Run deduplication for SOM report.
+    ROSE_INSTR_REPORT_CHAIN,      //!< Fire a chained report (MPV).
+    ROSE_INSTR_REPORT_SOM_INT,    //!< Manipulate SOM only.
+    ROSE_INSTR_REPORT_SOM_AWARE,  //!< Manipulate SOM from SOM-aware source.
+
+    /** \brief Fire a report. */
+    ROSE_INSTR_REPORT,
+
+    /** \brief Fire an exhaustible report. */
+    ROSE_INSTR_REPORT_EXHAUST,
+
+    /** \brief Fire a SOM report. */
+    ROSE_INSTR_REPORT_SOM,
+
+    /** \brief Fire an exhaustible SOM report. */
+    ROSE_INSTR_REPORT_SOM_EXHAUST,
+
+    /** \brief Super-instruction combining DEDUPE and REPORT. */
+    ROSE_INSTR_DEDUPE_AND_REPORT,
+
+    /**
+     * \brief Fire a report and stop program execution. This is a
+     * specialisation intended for short, frequently-executed programs.
+     */
+    ROSE_INSTR_FINAL_REPORT,
+
+    ROSE_INSTR_CHECK_EXHAUSTED,   //!< Check if an ekey has already been set.
+    ROSE_INSTR_CHECK_MIN_LENGTH,  //!< Check (EOM - SOM) against min length.
+    ROSE_INSTR_SET_STATE,         //!< Switch a state index on.
+    ROSE_INSTR_SET_GROUPS,        //!< Set some literal group bits.
+    ROSE_INSTR_SQUASH_GROUPS,     //!< Conditionally turn off some groups.
+    ROSE_INSTR_CHECK_STATE,       //!< Test a single bit in the state multibit.
+    ROSE_INSTR_SPARSE_ITER_BEGIN, //!< Begin running a sparse iter over states.
+    ROSE_INSTR_SPARSE_ITER_NEXT,  //!< Continue running sparse iter over states.
+    ROSE_INSTR_END                //!< End of program.
+};
+
+struct ROSE_STRUCT_ANCHORED_DELAY {
+    u8 code; //!< From enum RoseInstructionCode.
+    rose_group groups; //!< Bitmask.
+    u32 done_jump; //!< Jump forward this many bytes if successful.
+};
+
+union RoseLiteralMask {
+    u64a a64[MAX_MASK2_WIDTH / sizeof(u64a)];
+    u8 a8[MAX_MASK2_WIDTH];
+};
+
+/** Note: check failure will halt program. */
+struct ROSE_STRUCT_CHECK_LIT_MASK {
+    u8 code; //!< From enum RoseInstructionCode.
+    union RoseLiteralMask and_mask;
+    union RoseLiteralMask cmp_mask;
+};
+
+/** Note: check failure will halt program. */
+struct ROSE_STRUCT_CHECK_LIT_EARLY {
+    u8 code; //!< From enum RoseInstructionCode.
+};
+
+/** Note: check failure will halt program. */
+struct ROSE_STRUCT_CHECK_GROUPS {
+    u8 code; //!< From enum RoseInstructionCode.
+    rose_group groups; //!< Bitmask.
+};
+
+struct ROSE_STRUCT_CHECK_ONLY_EOD {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_CHECK_BOUNDS {
+    u8 code; //!< From enum RoseInstructionCode.
+    u64a min_bound; //!< Min distance from zero.
+    u64a max_bound; //!< Max distance from zero.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_CHECK_NOT_HANDLED {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 key; //!< Key in the "handled_roles" fatbit in scratch.
+    u32 fail_jump; //!< Jump forward this many bytes if we have seen key before.
+};
+
+struct ROSE_STRUCT_CHECK_LOOKAROUND {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 index;
+    u32 count;
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_CHECK_INFIX {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 queue; //!< Queue of leftfix to check.
+    u32 lag; //!< Lag of leftfix for this case.
+    ReportID report; //!< ReportID of leftfix to check.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_CHECK_PREFIX {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 queue; //!< Queue of leftfix to check.
+    u32 lag; //!< Lag of leftfix for this case.
+    ReportID report; //!< ReportID of leftfix to check.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_PUSH_DELAYED {
+    u8 code; //!< From enum RoseInstructionCode.
+    u8 delay; // Number of bytes to delay.
+    u32 index; // Delay literal index (relative to first delay lit).
+};
+
+struct ROSE_STRUCT_CATCH_UP {
+    u8 code; //!< From enum RoseInstructionCode.
+};
+
+struct ROSE_STRUCT_CATCH_UP_MPV {
+    u8 code; //!< From enum RoseInstructionCode.
+};
+
+struct ROSE_STRUCT_SOM_ADJUST {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 distance; //!< Distance to EOM.
+};
+
+struct ROSE_STRUCT_SOM_LEFTFIX {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 queue; //!< Queue index of leftfix providing SOM.
+    u32 lag; //!< Lag of leftfix for this case.
+};
+
+struct ROSE_STRUCT_SOM_FROM_REPORT {
+    u8 code; //!< From enum RoseInstructionCode.
+    struct som_operation som;
+};
+
+struct ROSE_STRUCT_SOM_ZERO {
+    u8 code; //!< From enum RoseInstructionCode.
+};
+
+struct ROSE_STRUCT_TRIGGER_INFIX {
+    u8 code; //!< From enum RoseInstructionCode.
+    u8 cancel; //!< Cancels previous top event.
+    u32 queue; //!< Queue index of infix.
+    u32 event; //!< Queue event, from MQE_*.
+};
+
+struct ROSE_STRUCT_TRIGGER_SUFFIX {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 queue; //!< Queue index of suffix.
+    u32 event; //!< Queue event, from MQE_*.
+};
+
+struct ROSE_STRUCT_DEDUPE {
+    u8 code; //!< From enum RoseInstructionCode.
+    u8 quash_som; //!< Force SOM to zero for this report.
+    u32 dkey; //!< Dedupe key.
+    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_DEDUPE_SOM {
+    u8 code; //!< From enum RoseInstructionCode.
+    u8 quash_som; //!< Force SOM to zero for this report.
+    u32 dkey; //!< Dedupe key.
+    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_REPORT_CHAIN {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 event; //!< Queue event, from MQE_*. Must be a top.
+
+    /**
+     * \brief Number of bytes behind us that we are allowed to squash
+     * identical top events on the queue.
+     */
+    u64a top_squash_distance;
+};
+
+struct ROSE_STRUCT_REPORT_SOM_INT {
+    u8 code; //!< From enum RoseInstructionCode.
+    struct som_operation som;
+};
+
+struct ROSE_STRUCT_REPORT_SOM_AWARE {
+    u8 code; //!< From enum RoseInstructionCode.
+    struct som_operation som;
+};
+
+struct ROSE_STRUCT_REPORT {
+    u8 code; //!< From enum RoseInstructionCode.
+    ReportID onmatch; //!< Report ID to deliver to user.
+    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
+};
+
+struct ROSE_STRUCT_REPORT_EXHAUST {
+    u8 code; //!< From enum RoseInstructionCode.
+    ReportID onmatch; //!< Report ID to deliver to user.
+    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
+    u32 ekey; //!< Exhaustion key.
+};
+
+struct ROSE_STRUCT_REPORT_SOM {
+    u8 code; //!< From enum RoseInstructionCode.
+    ReportID onmatch; //!< Report ID to deliver to user.
+    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
+};
+
+struct ROSE_STRUCT_REPORT_SOM_EXHAUST {
+    u8 code; //!< From enum RoseInstructionCode.
+    ReportID onmatch; //!< Report ID to deliver to user.
+    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
+    u32 ekey; //!< Exhaustion key.
+};
+
+struct ROSE_STRUCT_DEDUPE_AND_REPORT {
+    u8 code; //!< From enum RoseInstructionCode.
+    u8 quash_som; //!< Force SOM to zero for this report.
+    u32 dkey; //!< Dedupe key.
+    ReportID onmatch; //!< Report ID to deliver to user.
+    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_FINAL_REPORT {
+    u8 code; //!< From enum RoseInstructionCode.
+    ReportID onmatch; //!< Report ID to deliver to user.
+    s32 offset_adjust; //!< Offset adjustment to apply to end offset.
+};
+
+struct ROSE_STRUCT_CHECK_EXHAUSTED {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 ekey; //!< Exhaustion key to check.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_CHECK_MIN_LENGTH {
+    u8 code; //!< From enum RoseInstructionCode.
+    s32 end_adj; //!< Offset adjustment to add to EOM first.
+    u64a min_length; //!< Minimum distance from SOM to EOM.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_SET_STATE {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 index; //!< State index in multibit.
+};
+
+struct ROSE_STRUCT_SET_GROUPS {
+    u8 code; //!< From enum RoseInstructionCode.
+    rose_group groups; //!< Bitmask to OR into groups.
+};
+
+struct ROSE_STRUCT_SQUASH_GROUPS {
+    u8 code; //!< From enum RoseInstructionCode.
+    rose_group groups; //!< Bitmask to AND into groups.
+};
+
+struct ROSE_STRUCT_CHECK_STATE {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 index; //!< State index in the role multibit.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+/**
+ * Note that the offsets in the jump table are always relative to the start of
+ * the program, not the current instruction.
+ */
+struct ROSE_STRUCT_SPARSE_ITER_BEGIN {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 iter_offset; //!< Offset of mmbit_sparse_iter structure.
+    u32 jump_table; //!< Offset of jump table indexed by sparse iterator.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+/**
+ * Note that the offsets in the jump table are always relative to the start of
+ * the program, not the current instruction.
+ */
+struct ROSE_STRUCT_SPARSE_ITER_NEXT {
+    u8 code; //!< From enum RoseInstructionCode.
+    u32 iter_offset; //!< Offset of mmbit_sparse_iter structure.
+    u32 jump_table; //!< Offset of jump table indexed by sparse iterator.
+    u32 state; // Current state index.
+    u32 fail_jump; //!< Jump forward this many bytes on failure.
+};
+
+struct ROSE_STRUCT_END {
+    u8 code; //!< From enum RoseInstructionCode.
+};
+
+#endif // ROSE_ROSE_PROGRAM_H
diff --git a/src/rose/rose_sidecar_runtime.h b/src/rose/rose_sidecar_runtime.h
deleted file mode 100644
index 92a717fa..00000000
--- a/src/rose/rose_sidecar_runtime.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright (c) 2015, Intel Corporation
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of Intel Corporation nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef ROSE_SIDECAR_RUNTIME_H_1F746F6F237176
-#define ROSE_SIDECAR_RUNTIME_H_1F746F6F237176
-
-#include "hwlm/hwlm.h"
-#include "scratch.h"
-#include "sidecar/sidecar.h"
-#include "rose_common.h"
-#include "ue2common.h"
-
-// Callback defined in match.c
-void roseSidecarCallback(u64a offset, u32 side_id, void *context);
-
-static really_inline
-void catchup_sidecar(struct RoseContext *tctxt, u64a end) {
-    DEBUG_PRINTF("catching up the sidecar from %llu to %llu\n",
-                 tctxt->side_curr, end);
-    const struct sidecar *sidecar = getSLiteralMatcher(tctxt->t);
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-    struct core_info *ci = &scratch->core_info;
-
-    if (!sidecar || tctxt->side_curr == end) {
-        return;
-    }
-
-    const u8 *start;
-    if (tctxt->side_curr >=  ci->buf_offset) {
-        start = ci->buf + tctxt->side_curr - ci->buf_offset;
-        assert(end <= ci->buf_offset + ci->len);
-    } else {
-        /* at eod time we are called running over the histroy */
-        start = ci->hbuf + tctxt->side_curr - ci->buf_offset + ci->hlen;
-        assert(end <= ci->buf_offset);
-    }
-    size_t len = end - tctxt->side_curr;
-
-    DEBUG_PRINTF("enabled-->%02hhx\n",  *(u8 *)&scratch->side_enabled.arb);
-    sidecarExec(sidecar, start, len, &scratch->side_enabled.arb,
-                scratch->side_scratch, tctxt->side_curr, roseSidecarCallback,
-                tctxt);
-    tctxt->side_curr = end;
-
-    DEBUG_PRINTF("finished catching up the sidecar to %llu\n", end);
-}
-
-static rose_inline
-void enable_sidecar(struct RoseContext *tctxt, const struct RoseRole *tr) {
-    assert(tr->sidecarEnableOffset);
-    const struct sidecar *sidecar = getSLiteralMatcher(tctxt->t);
-    assert(sidecar);
-    struct hs_scratch *scratch = tctxtToScratch(tctxt);
-    DEBUG_PRINTF("welcome to the sidecar\n");
-    sidecarEnabledUnion(sidecar, &scratch->side_enabled.arb,
-           (const void *)((const char *)tctxt->t + tr->sidecarEnableOffset));
-}
-
-static really_inline
-void sidecar_enabled_populate(const struct RoseEngine *t,
-                              struct hs_scratch *scratch, const u8 *state) {
-    DEBUG_PRINTF("enabled-->%02hhx\n",  *(state + t->stateOffsets.sidecar));
-    memcpy(&scratch->side_enabled, state + t->stateOffsets.sidecar,
-           t->stateOffsets.sidecar_size);
-    DEBUG_PRINTF("enabled-->%02hhx\n",  *(u8 *)&scratch->side_enabled.arb);
-}
-
-static really_inline
-void sidecar_enabled_preserve(const struct RoseEngine *t,
-                              const struct hs_scratch *scratch, u8 *state) {
-    memcpy(state + t->stateOffsets.sidecar, &scratch->side_enabled,
-           t->stateOffsets.sidecar_size);
-}
-
-
-#endif /* ROSE_SIDECAR_RUNTIME_H_1F746F6F237176 */
diff --git a/src/rose/rose_types.h b/src/rose/rose_types.h
index 1b80b2b2..9dcef1ce 100644
--- a/src/rose/rose_types.h
+++ b/src/rose/rose_types.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,16 +26,46 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+/** \file
+ * \brief Rose runtime types (callbacks, etc).
+ */
+
 #ifndef ROSE_TYPES_H
 #define ROSE_TYPES_H
 
 #include "ue2common.h"
 
-struct RoseEngine;
+struct hs_scratch;
 
-// Note: identical signature to NfaCallback
-typedef int (*RoseCallback)(u64a offset, ReportID id, void *context);
+/**
+ * \brief Continue without checking for exhaustion.
+ *
+ * \ref RoseCallback return value indicating that execution should continue and
+ * that it is not necessary to check if all reports have been exhausted.
+ */
+#define ROSE_CONTINUE_MATCHING_NO_EXHAUST 2
+
+/**
+ * \brief The type for a Rose callback.
+ *
+ * \return
+ *  - \ref MO_HALT_MATCHING if matching should terminate;
+ *  - \ref MO_CONTINUE_MATCHING if matching should continue;
+ *  - \ref ROSE_CONTINUE_MATCHING_NO_EXHAUST if matching should continue and no
+ *    exhaustion is possible.
+ */
+typedef int (*RoseCallback)(u64a offset, ReportID id,
+                            struct hs_scratch *scratch);
+
+/**
+ * \brief The type for a Rose callback which also tracks start of match.
+ *
+ * Behaves just like \ref RoseCallback except that it is provided with both a
+ * start and an end offset.
+ *
+ * \see RoseCallback
+ */
 typedef int (*RoseCallbackSom)(u64a from_offset, u64a to_offset, ReportID id,
-                               void *context);
+                               struct hs_scratch *scratch);
 
 #endif
diff --git a/src/rose/runtime.h b/src/rose/runtime.h
index 2a87e3eb..d4309bfb 100644
--- a/src/rose/runtime.h
+++ b/src/rose/runtime.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -33,36 +33,29 @@
 #ifndef ROSE_RUNTIME_H
 #define ROSE_RUNTIME_H
 
-#include "scratch.h"
 #include "rose_internal.h"
+#include "scratch.h"
 #include "util/exhaust.h" // for isExhausted
-#include "util/internal_report.h"
 #include "util/partial_store.h"
 
 /*
  * ROSE STATE LAYOUT:
- *   state multibit
- *   runtime state structure
- *   full history table
- *   last history table
- *   short history table
- *   short queues (two multibits)
- *   last queues (two multibits)
- *   active array
- *   delay rb dirty
- *   nfa state
+ *
+ * - runtime status byte (halt status, delay rebuild dirty, etc)
+ * - rose state multibit
+ * - active leaf array (multibit)
+ * - active leftfix array (multibit)
+ * - leftfix lag table
+ * - anchored matcher state
+ * - literal groups
+ * - history buffer
+ * - exhausted bitvector
+ * - som slots, som multibit arrays
+ * - nfa stream state (for each nfa)
  */
 
 #define rose_inline really_inline
 
-/** \brief Fetch runtime state ptr. */
-static really_inline
-struct RoseRuntimeState *getRuntimeState(u8 *state) {
-    struct RoseRuntimeState *rs = (struct RoseRuntimeState *)(state);
-    assert(ISALIGNED_N(rs, 8));
-    return rs;
-}
-
 static really_inline
 const void *getByOffset(const struct RoseEngine *t, u32 offset) {
     assert(offset < t->size);
@@ -70,58 +63,49 @@ const void *getByOffset(const struct RoseEngine *t, u32 offset) {
 }
 
 static really_inline
-void *getRoleState(u8 *state) {
-    return state + sizeof(struct RoseRuntimeState);
+void *getRoleState(char *state) {
+    return state + sizeof(u8); // status flags
 }
 
 /** \brief Fetch the active array for suffix nfas. */
 static really_inline
-u8 *getActiveLeafArray(const struct RoseEngine *t, u8 *state) {
-    return state + t->stateOffsets.activeLeafArray;
+u8 *getActiveLeafArray(const struct RoseEngine *t, char *state) {
+    return (u8 *)(state + t->stateOffsets.activeLeafArray);
 }
 
 /** \brief Fetch the active array for rose nfas. */
 static really_inline
-u8 *getActiveLeftArray(const struct RoseEngine *t, u8 *state) {
-    return state + t->stateOffsets.activeLeftArray;
+u8 *getActiveLeftArray(const struct RoseEngine *t, char *state) {
+    return (u8 *)(state + t->stateOffsets.activeLeftArray);
 }
 
 static really_inline
-const u32 *getAnchoredInverseMap(const struct RoseEngine *t) {
-    return (const u32 *)(((const u8 *)t) + t->anchoredReportInverseMapOffset);
-}
-
-static really_inline
-const u32 *getAnchoredMap(const struct RoseEngine *t) {
-    return (const u32 *)(((const u8 *)t) + t->anchoredReportMapOffset);
-}
-
-static really_inline
-rose_group loadGroups(const struct RoseEngine *t, const u8 *state) {
+rose_group loadGroups(const struct RoseEngine *t, const char *state) {
     return partial_load_u64a(state + t->stateOffsets.groups,
                              t->stateOffsets.groups_size);
 
 }
 
 static really_inline
-void storeGroups(const struct RoseEngine *t, u8 *state, rose_group groups) {
+void storeGroups(const struct RoseEngine *t, char *state, rose_group groups) {
     partial_store_u64a(state + t->stateOffsets.groups, groups,
                        t->stateOffsets.groups_size);
 }
 
 static really_inline
-u8 * getFloatingMatcherState(const struct RoseEngine *t, u8 *state) {
-    return state + t->stateOffsets.floatingMatcherState;
+u8 *getFloatingMatcherState(const struct RoseEngine *t, char *state) {
+    return (u8 *)(state + t->stateOffsets.floatingMatcherState);
 }
 
 static really_inline
-u8 *getLeftfixLagTable(const struct RoseEngine *t, u8 *state) {
-    return state + t->stateOffsets.leftfixLagTable;
+u8 *getLeftfixLagTable(const struct RoseEngine *t, char *state) {
+    return (u8 *)(state + t->stateOffsets.leftfixLagTable);
 }
 
 static really_inline
-const u8 *getLeftfixLagTableConst(const struct RoseEngine *t, const u8 *state) {
-    return state + t->stateOffsets.leftfixLagTable;
+const u8 *getLeftfixLagTableConst(const struct RoseEngine *t,
+                                  const char *state) {
+    return (const u8 *)(state + t->stateOffsets.leftfixLagTable);
 }
 
 static rose_inline
@@ -134,11 +118,11 @@ char roseSuffixInfoIsExhausted(const struct RoseEngine *t,
 
     DEBUG_PRINTF("check exhaustion -> start at %u\n", info->ekeyListOffset);
 
-    /* END_EXHAUST terminated list */
+    /* INVALID_EKEY terminated list */
     const u32 *ekeys = (const u32 *)((const char *)t + info->ekeyListOffset);
-    while (*ekeys != END_EXHAUST) {
+    while (*ekeys != INVALID_EKEY) {
         DEBUG_PRINTF("check %u\n", *ekeys);
-        if (!isExhausted(exhausted, *ekeys)) {
+        if (!isExhausted(t, exhausted, *ekeys)) {
             DEBUG_PRINTF("not exhausted -> alive\n");
             return 0;
         }
@@ -162,27 +146,6 @@ u32 has_chained_nfas(const struct RoseEngine *t) {
     return t->outfixBeginQueue;
 }
 
-/** \brief Fetch \ref internal_report structure for this internal ID. */
-static really_inline
-const struct internal_report *getInternalReport(const struct RoseEngine *t,
-                                                ReportID intId) {
-    const struct internal_report *reports =
-        (const struct internal_report *)((const u8 *)t + t->intReportOffset);
-    assert(intId < t->intReportCount);
-    return reports + intId;
-}
-
-static really_inline
-const struct RoseRole *getRoleByOffset(const struct RoseEngine *t, u32 offset) {
-        const struct RoseRole *tr = (const void *)((const char *)t + offset);
-
-        assert((size_t)(tr - getRoleTable(t)) < t->roleCount);
-        DEBUG_PRINTF("get root role %zu\n", tr - getRoleTable(t));
-        return tr;
-}
-
-#define ANCHORED_MATCH_SENTINEL (~0U)
-
 static really_inline
 void updateLastMatchOffset(struct RoseContext *tctxt, u64a offset) {
     DEBUG_PRINTF("match @%llu, last match @%llu\n", offset,
diff --git a/src/rose/stream.c b/src/rose/stream.c
index b100eeae..b08fe04d 100644
--- a/src/rose/stream.c
+++ b/src/rose/stream.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -37,16 +37,13 @@
 #include "nfa/nfa_api_queue.h"
 #include "nfa/nfa_internal.h"
 #include "util/fatbit.h"
-#include "rose_sidecar_runtime.h"
 #include "rose.h"
 
 static rose_inline
 void runAnchoredTableStream(const struct RoseEngine *t, const void *atable,
                             size_t alen, u64a offset,
                             struct hs_scratch *scratch) {
-    char *state_base
-        = (char *)scratch->tctxt.state + t->stateOffsets.anchorState;
-
+    char *state_base = scratch->core_info.state + t->stateOffsets.anchorState;
     const struct anchored_matcher_info *curr = atable;
 
     do {
@@ -77,7 +74,7 @@ void runAnchoredTableStream(const struct RoseEngine *t, const void *atable,
                     goto next_nfa;
                 }
             } else {
-                if (!*(u16 *)state) {
+                if (!unaligned_load_u16(state)) {
                     goto next_nfa;
                 }
             }
@@ -86,11 +83,11 @@ void runAnchoredTableStream(const struct RoseEngine *t, const void *atable,
         if (nfa->type == MCCLELLAN_NFA_8) {
             nfaExecMcClellan8_SimpStream(nfa, state, scratch->core_info.buf,
                                          start, adj, alen, roseAnchoredCallback,
-                                         &scratch->tctxt);
+                                         scratch);
         } else {
             nfaExecMcClellan16_SimpStream(nfa, state, scratch->core_info.buf,
-                                          start, adj, alen, roseAnchoredCallback,
-                                          &scratch->tctxt);
+                                          start, adj, alen,
+                                          roseAnchoredCallback, scratch);
         }
 
     next_nfa:
@@ -129,7 +126,7 @@ enum MiracleAction {
 };
 
 static really_inline
-enum MiracleAction roseScanForMiracles(const struct RoseEngine *t, u8 *state,
+enum MiracleAction roseScanForMiracles(const struct RoseEngine *t, char *state,
                                        struct hs_scratch *scratch, u32 qi,
                                        const struct LeftNfaInfo *left,
                                        const struct NFA *nfa) {
@@ -178,7 +175,7 @@ found_miracle:
         nfaQueueInitState(q->nfa, q);
     } else {
         if (miracle_loc > end_loc - t->historyRequired) {
-            u8 *streamState = state + getNfaInfoByQueue(t, qi)->stateOffset;
+            char *streamState = state + getNfaInfoByQueue(t, qi)->stateOffset;
             u64a offset = ci->buf_offset + miracle_loc;
             u8 key = offset ? getByteBefore(ci, miracle_loc) : 0;
             DEBUG_PRINTF("init state, key=0x%02x, offset=%llu\n", key, offset);
@@ -193,7 +190,7 @@ found_miracle:
                      miracle_loc);
         if (!q_active) {
             fatbit_set(scratch->aqa, qCount, qi);
-            initRoseQueue(t, qi, left, &scratch->tctxt);
+            initRoseQueue(t, qi, left, scratch);
         }
         q->cur = q->end = 0;
         pushQueueAt(q, 0, MQE_START, miracle_loc);
@@ -206,7 +203,7 @@ found_miracle:
 
 
 static really_inline
-char roseCatchUpLeftfix(const struct RoseEngine *t, u8 *state,
+char roseCatchUpLeftfix(const struct RoseEngine *t, char *state,
                         struct hs_scratch *scratch, u32 qi,
                         const struct LeftNfaInfo *left) {
     assert(!left->transient); // active roses only
@@ -239,7 +236,7 @@ char roseCatchUpLeftfix(const struct RoseEngine *t, u8 *state,
     }
 
     if (!fatbit_set(scratch->aqa, qCount, qi)) {
-        initRoseQueue(t, qi, left, &scratch->tctxt);
+        initRoseQueue(t, qi, left, scratch);
 
         s32 sp;
         if (ci->buf_offset) {
@@ -294,7 +291,7 @@ char roseCatchUpLeftfix(const struct RoseEngine *t, u8 *state,
             DEBUG_PRINTF("infix died of old age\n");
             return 0;
         }
-        reduceQueue(q, last_loc, left->maxQueueLen, q->nfa->maxWidth);
+        reduceInfixQueue(q, last_loc, left->maxQueueLen, q->nfa->maxWidth);
     }
 
     DEBUG_PRINTF("end scan at %lld\n", last_loc);
@@ -324,7 +321,7 @@ char roseCatchUpLeftfix(const struct RoseEngine *t, u8 *state,
 }
 
 static rose_inline
-void roseCatchUpLeftfixes(const struct RoseEngine *t, u8 *state,
+void roseCatchUpLeftfixes(const struct RoseEngine *t, char *state,
                           struct hs_scratch *scratch) {
     if (!t->activeLeftIterOffset) {
         // No sparse iter, no non-transient roses.
@@ -343,12 +340,13 @@ void roseCatchUpLeftfixes(const struct RoseEngine *t, u8 *state,
     const u32 arCount = t->activeLeftCount;
     const struct LeftNfaInfo *left_table = getLeftTable(t);
     const struct mmbit_sparse_iter *it = getActiveLeftIter(t);
-    struct mmbit_sparse_state *s = scratch->sparse_iter_state;
+
+    struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES];
 
     u32 idx = 0;
-    u32 ri = mmbit_sparse_iter_begin(ara, arCount, &idx, it, s);
+    u32 ri = mmbit_sparse_iter_begin(ara, arCount, &idx, it, si_state);
     for (; ri != MMB_INVALID;
-           ri = mmbit_sparse_iter_next(ara, arCount, ri, &idx, it, s)) {
+           ri = mmbit_sparse_iter_next(ara, arCount, ri, &idx, it, si_state)) {
         const struct LeftNfaInfo *left = left_table + ri;
         u32 qi = ri + t->leftfixBeginQueue;
         DEBUG_PRINTF("leftfix %u of %u, maxLag=%u, infix=%d\n", ri, arCount,
@@ -365,7 +363,7 @@ void roseCatchUpLeftfixes(const struct RoseEngine *t, u8 *state,
 
 // Saves out stream state for all our active suffix NFAs.
 static rose_inline
-void roseSaveNfaStreamState(const struct RoseEngine *t, u8 *state,
+void roseSaveNfaStreamState(const struct RoseEngine *t, char *state,
                             struct hs_scratch *scratch) {
     struct mq *queues = scratch->queues;
     u8 *aa = getActiveLeafArray(t, state);
@@ -393,26 +391,20 @@ void roseSaveNfaStreamState(const struct RoseEngine *t, u8 *state,
 }
 
 static rose_inline
-void ensureStreamNeatAndTidy(const struct RoseEngine *t, u8 *state,
+void ensureStreamNeatAndTidy(const struct RoseEngine *t, char *state,
                              struct hs_scratch *scratch, size_t length,
-                             u64a offset, u8 delay_rb_status) {
+                             u64a offset) {
     struct RoseContext *tctxt = &scratch->tctxt;
 
-    if (roseCatchUpTo(t, state, length + scratch->core_info.buf_offset, scratch,
-                     0)
-        == HWLM_TERMINATE_MATCHING) {
+    if (roseCatchUpTo(t, scratch, length + scratch->core_info.buf_offset) ==
+        HWLM_TERMINATE_MATCHING) {
         return; /* dead; no need to clean up state. */
     }
     roseSaveNfaStreamState(t, state, scratch);
     roseCatchUpLeftfixes(t, state, scratch);
-    roseFlushLastByteHistory(t, state, offset + length, tctxt);
+    roseFlushLastByteHistory(t, scratch, offset + length);
     tctxt->lastEndOffset = offset + length;
-    catchup_sidecar(tctxt, offset + length);
-    sidecar_enabled_preserve(t, scratch, state);
     storeGroups(t, state, tctxt->groups);
-    struct RoseRuntimeState *rstate = getRuntimeState(state);
-    rstate->stored_depth = tctxt->depth;
-    rstate->flags = delay_rb_status;
 }
 
 static really_inline
@@ -423,20 +415,23 @@ void do_rebuild(const struct RoseEngine *t, const struct HWLM *ftable,
     const u8 *buf = scratch->core_info.hbuf + scratch->core_info.hlen - len;
     DEBUG_PRINTF("BEGIN FLOATING REBUILD over %zu bytes\n", len);
 
+    scratch->core_info.status &= ~STATUS_DELAY_DIRTY;
+
     hwlmExec(ftable, buf, len, 0, roseDelayRebuildCallback, scratch,
              scratch->tctxt.groups);
     assert(!can_stop_matching(scratch));
 }
 
-void roseStreamExec(const struct RoseEngine *t, u8 *state,
-                   struct hs_scratch *scratch, RoseCallback callback,
-                   RoseCallbackSom som_callback, void *ctx) {
+void roseStreamExec(const struct RoseEngine *t, struct hs_scratch *scratch) {
     DEBUG_PRINTF("OH HAI\n");
     assert(t);
-    assert(state);
     assert(scratch->core_info.hbuf);
     assert(scratch->core_info.buf);
 
+    // We should not have been called if we've already been told to terminate
+    // matching.
+    assert(!told_to_stop_matching(scratch));
+
     assert(mmbit_sparse_iter_state_size(t->rolesWithStateCount)
            < MAX_SPARSE_ITER_STATES);
 
@@ -452,34 +447,23 @@ void roseStreamExec(const struct RoseEngine *t, u8 *state,
         return;
     }
 
-    struct RoseRuntimeState *rstate = getRuntimeState(state);
+    char *state = scratch->core_info.state;
 
     struct RoseContext *tctxt = &scratch->tctxt;
-    tctxt->t = t;
-    tctxt->depth = rstate->stored_depth;
     tctxt->mpv_inactive = 0;
     tctxt->groups = loadGroups(t, state);
     tctxt->lit_offset_adjust = offset + 1; // index after last byte
     tctxt->delayLastEndOffset = offset;
     tctxt->lastEndOffset = offset;
     tctxt->filledDelayedSlots = 0;
-    tctxt->state = state;
-    tctxt->cb = callback;
-    tctxt->cb_som = som_callback;
-    tctxt->userCtx = ctx;
     tctxt->lastMatchOffset = 0;
     tctxt->minMatchOffset = offset;
     tctxt->minNonMpvMatchOffset = offset;
     tctxt->next_mpv_offset = 0;
-    tctxt->curr_anchored_loc = MMB_INVALID;
-    tctxt->curr_row_offset = 0;
-    tctxt->side_curr = offset;
-
     DEBUG_PRINTF("BEGIN: history len=%zu, buffer len=%zu\n",
                   scratch->core_info.hlen, scratch->core_info.len);
 
     fatbit_clear(scratch->aqa);
-    scratch->am_log_sum = 0; /* clear the anchored logs */
     scratch->al_log_sum = 0;
     scratch->catchup_pq.qm_size = 0;
 
@@ -487,10 +471,6 @@ void roseStreamExec(const struct RoseEngine *t, u8 *state,
         streamInitSufPQ(t, state, scratch);
     }
 
-    sidecar_enabled_populate(t, scratch, state);
-
-    u8 delay_rb_status = rstate->flags;
-
     u32 alen = t->anchoredDistance > offset ?
         MIN(length + offset, t->anchoredDistance) - offset : 0;
 
@@ -502,13 +482,11 @@ void roseStreamExec(const struct RoseEngine *t, u8 *state,
         if (can_stop_matching(scratch)) {
             goto exit;
         }
-
-        resetAnchoredLog(t, scratch);
     }
 
     const struct HWLM *ftable = getFLiteralMatcher(t);
     if (ftable) {
-        if (t->noFloatingRoots && tctxt->depth == 1) {
+        if (t->noFloatingRoots && !roseHasInFlightMatches(t, state, scratch)) {
             DEBUG_PRINTF("skip FLOATING: no inflight matches\n");
             goto flush_delay_and_exit;
         }
@@ -521,12 +499,13 @@ void roseStreamExec(const struct RoseEngine *t, u8 *state,
 
         size_t hlength = scratch->core_info.hlen;
 
-        char rebuild = hlength && (delay_rb_status & DELAY_FLOAT_DIRTY)
-            && (t->maxFloatingDelayedMatch == ROSE_BOUND_INF
-                || offset < t->maxFloatingDelayedMatch);
+        char rebuild = hlength &&
+                       (scratch->core_info.status & STATUS_DELAY_DIRTY) &&
+                       (t->maxFloatingDelayedMatch == ROSE_BOUND_INF ||
+                        offset < t->maxFloatingDelayedMatch);
         DEBUG_PRINTF("**rebuild %hhd status %hhu mfdm %u, offset %llu\n",
-                     rebuild, delay_rb_status, t->maxFloatingDelayedMatch,
-                     offset);
+                     rebuild, scratch->core_info.status,
+                     t->maxFloatingDelayedMatch, offset);
 
         if (!flen) {
             if (rebuild) { /* rebuild floating delayed match stuff */
@@ -560,23 +539,22 @@ void roseStreamExec(const struct RoseEngine *t, u8 *state,
         }
 
         DEBUG_PRINTF("BEGIN FLOATING (over %zu/%zu)\n", flen, length);
-        hwlmExecStreaming(ftable, scratch, flen, start, roseCallback, tctxt,
+        hwlmExecStreaming(ftable, scratch, flen, start, roseCallback, scratch,
                           tctxt->groups, stream_state);
     }
 
 flush_delay_and_exit:
     DEBUG_PRINTF("flushing floating\n");
-    if (cleanUpDelayed(length, offset, tctxt, &delay_rb_status)
-        == HWLM_TERMINATE_MATCHING) {
+    if (cleanUpDelayed(t, scratch, length, offset) == HWLM_TERMINATE_MATCHING) {
         return;
     }
 
 exit:
     DEBUG_PRINTF("CLEAN UP TIME\n");
     if (!can_stop_matching(scratch)) {
-        ensureStreamNeatAndTidy(t, state, scratch, length, offset,
-                                delay_rb_status);
+        ensureStreamNeatAndTidy(t, state, scratch, length, offset);
     }
-    DEBUG_PRINTF("DONE STREAMING SCAN, dirty = %hhu\n", delay_rb_status);
+    DEBUG_PRINTF("DONE STREAMING SCAN, status = %u\n",
+                 scratch->core_info.status);
     return;
 }
diff --git a/src/runtime.c b/src/runtime.c
index 335a83bc..95f21d84 100644
--- a/src/runtime.c
+++ b/src/runtime.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -47,6 +47,7 @@
 #include "rose/rose.h"
 #include "rose/runtime.h"
 #include "database.h"
+#include "report.h"
 #include "scratch.h"
 #include "som/som_runtime.h"
 #include "som/som_stream.h"
@@ -56,8 +57,6 @@
 #include "util/fatbit.h"
 #include "util/multibit.h"
 
-#define DEDUPE_MATCHES
-
 static really_inline
 void prefetch_data(const char *data, unsigned length) {
     __builtin_prefetch(data);
@@ -120,7 +119,8 @@ static really_inline
 void populateCoreInfo(struct hs_scratch *s, const struct RoseEngine *rose,
                       char *state, match_event_handler onEvent, void *userCtx,
                       const char *data, size_t length, const u8 *history,
-                      size_t hlen, u64a offset, UNUSED unsigned int flags) {
+                      size_t hlen, u64a offset, u8 status,
+                      UNUSED unsigned int flags) {
     assert(rose);
     s->core_info.userContext = userCtx;
     s->core_info.userCallback = onEvent ? onEvent : null_onEvent;
@@ -128,7 +128,7 @@ void populateCoreInfo(struct hs_scratch *s, const struct RoseEngine *rose,
     s->core_info.state = state; /* required for chained queues + evec */
 
     s->core_info.exhaustionVector = state + rose->stateOffsets.exhausted;
-    s->core_info.broken = NOT_BROKEN;
+    s->core_info.status = status;
     s->core_info.buf = (const u8 *)data;
     s->core_info.len = length;
     s->core_info.hbuf = history;
@@ -139,542 +139,39 @@ void populateCoreInfo(struct hs_scratch *s, const struct RoseEngine *rose,
     s->som_set_now_offset = ~0ULL;
     s->deduper.current_report_offset = ~0ULL;
     s->deduper.som_log_dirty = 1; /* som logs have not been cleared */
+
+    // Rose program execution (used for some report paths) depends on these
+    // values being initialised.
+    s->tctxt.lastMatchOffset = 0;
+    s->tctxt.minMatchOffset = offset;
+    s->tctxt.minNonMpvMatchOffset = offset;
 }
 
-/** \brief Query whether this stream is broken.
- *
- * A broken stream is one on which scanning has stopped, either because the
- * user has told us to (via the return value from a match callback) or because
- * we have exhausted all reports.
- *
- * \return NOT_BROKEN, BROKEN_FROM_USER or BROKEN_EXHAUSTED.
- */
+#define STATUS_VALID_BITS                                                      \
+    (STATUS_TERMINATED | STATUS_EXHAUSTED | STATUS_DELAY_DIRTY)
+
+/** \brief Retrieve status bitmask from stream state. */
 static really_inline
-u8 getBroken(const char *state) {
-    const struct RoseRuntimeState *ts = (const void *)state;
-    assert(ts->broken == NOT_BROKEN || ts->broken == BROKEN_FROM_USER
-           || ts->broken == BROKEN_EXHAUSTED);
-    return ts->broken;
+u8 getStreamStatus(const char *state) {
+    u8 status = *(const u8 *)state;
+    assert((status & ~STATUS_VALID_BITS) == 0);
+    return status;
 }
 
-/** \brief Mark this stream with the given broken flag.
- *
- * Possible values: NOT_BROKEN, BROKEN_FROM_USER, BROKEN_EXHAUSTED.
- */
+/** \brief Store status bitmask to stream state. */
 static really_inline
-void setBroken(char *state, u8 broken) {
-    DEBUG_PRINTF("set broken=%d\n", broken);
-    assert(broken == NOT_BROKEN || broken == BROKEN_FROM_USER
-           || broken == BROKEN_EXHAUSTED);
-    struct RoseRuntimeState *ts = (void *)state;
-    ts->broken = broken;
-}
-
-static really_inline
-int roseAdaptor_i(u64a offset, ReportID id, void *context, char is_simple,
-                  char do_som) {
-    assert(id != MO_INVALID_IDX); // Should never get an invalid ID.
-
-    struct hs_scratch *scratch = (struct hs_scratch *)context;
-    struct core_info *ci = &scratch->core_info;
-    const struct RoseEngine *rose = ci->rose;
-    DEBUG_PRINTF("internal report %u\n", id);
-    const struct internal_report *ri = getInternalReport(rose, id);
-
-    assert(isExternalReport(ri)); /* only external reports should reach here */
-
-    s32 offset_adj = ri->offsetAdjust;
-    UNUSED u32 dkey = ri->dkey;
-    u64a to_offset = offset;
-    u64a from_offset = 0;
-    UNUSED u32 dkeyCount = rose->dkeyCount;
-
-    u32 flags = 0;
-#ifndef RELEASE_BUILD
-    if (offset_adj) {
-        // alert testing tools that we've got adjusted matches
-        flags |= HS_MATCH_FLAG_ADJUSTED;
-    }
-#endif
-
-    DEBUG_PRINTF("internal match at %llu: IID=%u type=%hhu RID=%u "
-                 "offsetAdj=%d\n", offset, id, ri->type, ri->onmatch,
-                 offset_adj);
-
-    if (unlikely(can_stop_matching(scratch))) { /* ok - we are from rose */
-        DEBUG_PRINTF("pre broken - halting\n");
-        return MO_HALT_MATCHING;
-    }
-
-    if (!is_simple && ri->hasBounds) {
-        assert(ri->minOffset || ri->minLength || ri->maxOffset < MAX_OFFSET);
-        assert(ri->minOffset <= ri->maxOffset);
-        if (offset < ri->minOffset || offset > ri->maxOffset) {
-            DEBUG_PRINTF("match fell outside valid range %llu !: [%llu,%llu]\n",
-                         offset, ri->minOffset, ri->maxOffset);
-            return ROSE_CONTINUE_MATCHING_NO_EXHAUST;
-        }
-    }
-
-    if (!is_simple && unlikely(isExhausted(ci->exhaustionVector, ri->ekey))) {
-        DEBUG_PRINTF("ate exhausted match\n");
-        return MO_CONTINUE_MATCHING;
-    }
-
-    if (ri->type == EXTERNAL_CALLBACK) {
-        from_offset = 0;
-    } else if (do_som) {
-        from_offset = handleSomExternal(scratch, ri, to_offset);
-    }
-
-    to_offset += offset_adj;
-    assert(from_offset == HS_OFFSET_PAST_HORIZON || from_offset <= to_offset);
-
-    if (do_som && ri->minLength) {
-        if (from_offset != HS_OFFSET_PAST_HORIZON &&
-                (to_offset - from_offset < ri->minLength)) {
-            return ROSE_CONTINUE_MATCHING_NO_EXHAUST;
-        }
-        if (ri->quashSom) {
-            from_offset = 0;
-        }
-    }
-
-    DEBUG_PRINTF(">> reporting match @[%llu,%llu] for sig %u ctxt %p <<\n",
-                 from_offset, to_offset, ri->onmatch, ci->userContext);
-
-    int halt = 0;
-
-    if (do_som || dkey != MO_INVALID_IDX) {
-        if (offset != scratch->deduper.current_report_offset) {
-            assert(scratch->deduper.current_report_offset == ~0ULL ||
-                   scratch->deduper.current_report_offset < offset);
-            if (offset == scratch->deduper.current_report_offset + 1) {
-                fatbit_clear(scratch->deduper.log[offset % 2]);
-            } else {
-                fatbit_clear(scratch->deduper.log[0]);
-                fatbit_clear(scratch->deduper.log[1]);
-            }
-
-            DEBUG_PRINTF("adj dedupe offset %hhd\n", do_som);
-            if (do_som) {
-                halt = flushStoredSomMatches(scratch, offset);
-                if (halt) {
-                    goto exit;
-                }
-            }
-            scratch->deduper.current_report_offset = offset;
-        }
-    }
-
-#ifdef DEDUPE_MATCHES
-    if (dkey != MO_INVALID_IDX) {
-        if (ri->type == EXTERNAL_CALLBACK || ri->quashSom) {
-            DEBUG_PRINTF("checking dkey %u at offset %llu\n", dkey, to_offset);
-            assert(offset_adj == 0 || offset_adj == -1);
-            if (fatbit_set(scratch->deduper.log[to_offset % 2], dkeyCount,
-                           dkey)) {
-                /* we have already raised this report at this offset, squash dupe
-                 * match. */
-                DEBUG_PRINTF("dedupe\n");
-                goto exit;
-            }
-        } else if (do_som) {
-            /* SOM external event */
-            DEBUG_PRINTF("checking dkey %u at offset %llu\n", dkey, to_offset);
-            assert(offset_adj == 0 || offset_adj == -1);
-            u64a *starts = scratch->deduper.som_start_log[to_offset % 2];
-            if (fatbit_set(scratch->deduper.som_log[to_offset % 2], dkeyCount,
-                           dkey)) {
-                starts[dkey] = MIN(starts[dkey], from_offset);
-            } else {
-                starts[dkey] = from_offset;
-            }
-
-            if (offset_adj) {
-                scratch->deduper.som_log_dirty |= 1;
-            } else {
-                scratch->deduper.som_log_dirty |= 2;
-            }
-
-            goto exit;
-        }
-    }
-#endif
-
-    halt = ci->userCallback((unsigned int)ri->onmatch, from_offset, to_offset,
-                            flags, ci->userContext);
-#ifdef DEDUPE_MATCHES
-exit:
-#endif
-    if (halt) {
-        DEBUG_PRINTF("callback requested to terminate matches\n");
-
-        setBroken(ci->state, BROKEN_FROM_USER);
-        ci->broken = BROKEN_FROM_USER;
-
-        return MO_HALT_MATCHING;
-    }
-
-    if (!is_simple && ri->ekey != END_EXHAUST) {
-        markAsMatched(ci->exhaustionVector, ri->ekey);
-        return MO_CONTINUE_MATCHING;
-    } else {
-        return ROSE_CONTINUE_MATCHING_NO_EXHAUST;
-    }
-}
-
-static really_inline
-int roseSomAdaptor_i(u64a from_offset, u64a to_offset, ReportID id,
-                     void *context, char is_simple) {
-    assert(id != MO_INVALID_IDX); // Should never get an invalid ID.
-
-    u32 flags = 0;
-
-    struct hs_scratch *scratch = (struct hs_scratch *)context;
-    struct core_info *ci = &scratch->core_info;
-    const struct RoseEngine *rose = ci->rose;
-    const struct internal_report *ri = getInternalReport(rose, id);
-
-    /* internal events should be handled by rose directly */
-    assert(ri->type == EXTERNAL_CALLBACK);
-
-    DEBUG_PRINTF("internal match at %llu: IID=%u type=%hhu RID=%u "
-                 "offsetAdj=%d\n", to_offset, id, ri->type, ri->onmatch,
-                 ri->offsetAdjust);
-
-    if (unlikely(can_stop_matching(scratch))) {
-        DEBUG_PRINTF("pre broken - halting\n");
-        return MO_HALT_MATCHING;
-    }
-
-    if (!is_simple && ri->hasBounds) {
-        assert(ri->minOffset || ri->minLength || ri->maxOffset < MAX_OFFSET);
-        if (to_offset < ri->minOffset || to_offset > ri->maxOffset) {
-            DEBUG_PRINTF("match fell outside valid range %llu !: [%llu,%llu]\n",
-                         to_offset, ri->minOffset, ri->maxOffset);
-            return MO_CONTINUE_MATCHING;
-        }
-    }
-
-    int halt = 0;
-
-    if (!is_simple && unlikely(isExhausted(ci->exhaustionVector, ri->ekey))) {
-        DEBUG_PRINTF("ate exhausted match\n");
-        goto do_return;
-    }
-
-#ifdef DEDUPE_MATCHES
-    u64a offset = to_offset;
-#endif
-
-    to_offset += ri->offsetAdjust;
-    assert(from_offset == HS_OFFSET_PAST_HORIZON || from_offset <= to_offset);
-
-    if (!is_simple && ri->minLength) {
-        if (from_offset != HS_OFFSET_PAST_HORIZON &&
-                (to_offset - from_offset < ri->minLength)) {
-            return MO_CONTINUE_MATCHING;
-        }
-        if (ri->quashSom) {
-            from_offset = 0;
-        }
-    }
-
-    DEBUG_PRINTF(">> reporting match @[%llu,%llu] for sig %u ctxt %p <<\n",
-                 from_offset, to_offset, ri->onmatch, ci->userContext);
-
-#ifndef RELEASE_BUILD
-    if (ri->offsetAdjust != 0) {
-        // alert testing tools that we've got adjusted matches
-        flags |= HS_MATCH_FLAG_ADJUSTED;
-    }
-#endif
-
-#ifdef DEDUPE_MATCHES
-    u32 dkeyCount = rose->dkeyCount;
-
-    if (offset != scratch->deduper.current_report_offset) {
-
-        assert(scratch->deduper.current_report_offset == ~0ULL
-               || scratch->deduper.current_report_offset < offset);
-        if (offset == scratch->deduper.current_report_offset + 1) {
-            fatbit_clear(scratch->deduper.log[offset % 2]);
-        } else {
-            fatbit_clear(scratch->deduper.log[0]);
-            fatbit_clear(scratch->deduper.log[1]);
-        }
-
-        halt = flushStoredSomMatches(scratch, offset);
-        if (halt) {
-            goto do_return;
-        }
-
-        scratch->deduper.current_report_offset = offset;
-    }
-
-    u32 dkey = ri->dkey;
-    if (dkey != MO_INVALID_IDX) {
-        if (ri->quashSom) {
-            DEBUG_PRINTF("checking dkey %u at offset %llu\n", dkey, to_offset);
-            assert(ri->offsetAdjust == 0 || ri->offsetAdjust == -1);
-            if (fatbit_set(scratch->deduper.log[to_offset % 2], dkeyCount,
-                           dkey)) {
-                /* we have already raised this report at this offset, squash
-                 * dupe match. */
-                DEBUG_PRINTF("dedupe\n");
-                goto do_return;
-            }
-        } else {
-            /* SOM external event */
-            DEBUG_PRINTF("checking dkey %u at offset %llu\n", dkey, to_offset);
-            assert(ri->offsetAdjust == 0 || ri->offsetAdjust == -1);
-            u64a *starts = scratch->deduper.som_start_log[to_offset % 2];
-            if (fatbit_set(scratch->deduper.som_log[to_offset % 2], dkeyCount,
-                           dkey)) {
-                starts[dkey] = MIN(starts[dkey], from_offset);
-            } else {
-                starts[dkey] = from_offset;
-            }
-
-            if (ri->offsetAdjust) {
-                scratch->deduper.som_log_dirty |= 1;
-            } else {
-                scratch->deduper.som_log_dirty |= 2;
-            }
-
-            goto do_return;
-        }
-    }
-#endif
-
-    halt = ci->userCallback((unsigned int)ri->onmatch, from_offset, to_offset,
-                            flags, ci->userContext);
-
-    if (!is_simple) {
-        markAsMatched(ci->exhaustionVector, ri->ekey);
-    }
-
-do_return:
-    if (halt) {
-        DEBUG_PRINTF("callback requested to terminate matches\n");
-
-        setBroken(ci->state, BROKEN_FROM_USER);
-        ci->broken = BROKEN_FROM_USER;
-
-        return MO_HALT_MATCHING;
-    }
-
-    return MO_CONTINUE_MATCHING;
-}
-
-static really_inline
-hwlmcb_rv_t multiDirectAdaptor(u64a real_end, ReportID direct_id, void *context,
-                               struct core_info *ci, char is_simple,
-                               char do_som) {
-    // Multi-direct report, list of reports indexed by the ID.
-    u32 mdr_offset = direct_id & ~LITERAL_MDR_FLAG;
-    const struct RoseEngine *t = ci->rose;
-    const ReportID *id
-        = (const ReportID *)((const char *)t + t->multidirectOffset)
-        + mdr_offset;
-    for (; *id != MO_INVALID_IDX; id++) {
-        int rv = roseAdaptor_i(real_end, *id, context, is_simple, do_som);
-        if (rv == MO_HALT_MATCHING) {
-            return HWLM_TERMINATE_MATCHING;
-        }
-    }
-    return HWLM_CONTINUE_MATCHING;
-}
-
-static
-int roseAdaptor(u64a offset, ReportID id, void *context) {
-    return roseAdaptor_i(offset, id, context, 0, 0);
-}
-
-static
-hwlmcb_rv_t hwlmAdaptor(UNUSED size_t start, size_t end, u32 direct_id,
-                        void *context) {
-    struct hs_scratch *scratch = (struct hs_scratch *)context;
-    struct core_info *ci = &scratch->core_info;
-    u64a real_end = (u64a)end + ci->buf_offset + 1;
-
-    if (isLiteralMDR(direct_id)) {
-        return multiDirectAdaptor(real_end, direct_id, context, ci, 0, 0);
-    }
-
-    ReportID id = literalToReport(direct_id);
-    int rv = roseAdaptor_i(real_end, id, context, 0, 0);
-    if (rv == MO_CONTINUE_MATCHING || rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
-        return HWLM_CONTINUE_MATCHING;
-    } else {
-        return HWLM_TERMINATE_MATCHING;
-    }
-}
-
-static
-int roseSimpleAdaptor(u64a offset, ReportID id, void *context) {
-    return roseAdaptor_i(offset, id, context, 1, 0);
-}
-
-static
-hwlmcb_rv_t hwlmSimpleAdaptor(UNUSED size_t start, size_t end, u32 direct_id,
-                              void *context) {
-    struct hs_scratch *scratch = (struct hs_scratch *)context;
-    struct core_info *ci = &scratch->core_info;
-    u64a real_end = (u64a)end + ci->buf_offset + 1;
-
-    if (isLiteralMDR(direct_id)) {
-        return multiDirectAdaptor(real_end, direct_id, context, ci, 1, 0);
-    }
-
-    // Single direct report.
-    ReportID id = literalToReport(direct_id);
-    int rv = roseAdaptor_i(real_end, id, context, 1, 0);
-    if (rv == MO_CONTINUE_MATCHING || rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
-        return HWLM_CONTINUE_MATCHING;
-    } else {
-        return HWLM_TERMINATE_MATCHING;
-    }
-}
-
-static
-int roseSomAdaptor(u64a offset, ReportID id, void *context) {
-    return roseAdaptor_i(offset, id, context, 0, 1);
-}
-
-static
-hwlmcb_rv_t hwlmSomAdaptor(UNUSED size_t start, size_t end, u32 direct_id,
-                           void *context) {
-    struct hs_scratch *scratch = (struct hs_scratch *)context;
-    struct core_info *ci = &scratch->core_info;
-    u64a real_end = (u64a)end + ci->buf_offset + 1;
-
-    if (isLiteralMDR(direct_id)) {
-        return multiDirectAdaptor(real_end, direct_id, context, ci, 0, 1);
-    }
-
-    ReportID id = literalToReport(direct_id);
-    int rv = roseAdaptor_i(real_end, id, context, 0, 1);
-    if (rv == MO_CONTINUE_MATCHING || rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
-        return HWLM_CONTINUE_MATCHING;
-    } else {
-        return HWLM_TERMINATE_MATCHING;
-    }
-}
-
-static
-int roseSimpleSomAdaptor(u64a offset, ReportID id, void *context) {
-    return roseAdaptor_i(offset, id, context, 1, 1);
-}
-
-static
-hwlmcb_rv_t hwlmSimpleSomAdaptor(UNUSED size_t start, size_t end, u32 direct_id,
-                                 void *context) {
-    struct hs_scratch *scratch = (struct hs_scratch *)context;
-    struct core_info *ci = &scratch->core_info;
-    u64a real_end = (u64a)end + ci->buf_offset + 1;
-
-    if (isLiteralMDR(direct_id)) {
-        return multiDirectAdaptor(real_end, direct_id, context, ci, 1, 1);
-    }
-
-    ReportID id = literalToReport(direct_id);
-    int rv = roseAdaptor_i(real_end, id, context, 1, 1);
-    if (rv == MO_CONTINUE_MATCHING || rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) {
-        return HWLM_CONTINUE_MATCHING;
-    } else {
-        return HWLM_TERMINATE_MATCHING;
-    }
-}
-
-static really_inline
-RoseCallback selectAdaptor(const struct RoseEngine *rose) {
-    const char is_simple = rose->simpleCallback;
-    const char do_som = rose->hasSom;
-
-    if (do_som) {
-        return is_simple ? roseSimpleSomAdaptor : roseSomAdaptor;
-    } else {
-        return is_simple ? roseSimpleAdaptor : roseAdaptor;
-    }
-}
-
-static really_inline
-HWLMCallback selectHwlmAdaptor(const struct RoseEngine *rose) {
-    const char is_simple = rose->simpleCallback;
-    const char do_som = rose->hasSom;
-
-    if (do_som) {
-        return is_simple ? hwlmSimpleSomAdaptor : hwlmSomAdaptor;
-    } else {
-        return is_simple ? hwlmSimpleAdaptor : hwlmAdaptor;
-    }
-}
-
-static
-int roseSomSomAdaptor(u64a from_offset, u64a to_offset, ReportID id,
-                       void *context) {
-    return roseSomAdaptor_i(from_offset, to_offset, id, context, 0);
-}
-
-static
-int roseSimpleSomSomAdaptor(u64a from_offset, u64a to_offset, ReportID id,
-                             void *context) {
-    return roseSomAdaptor_i(from_offset, to_offset, id, context, 1);
-}
-
-static really_inline
-RoseCallbackSom selectSomAdaptor(const struct RoseEngine *rose) {
-    const char is_simple = rose->simpleCallback;
-
-    return is_simple ? roseSimpleSomSomAdaptor : roseSomSomAdaptor;
-}
-
-static never_inline
-void processReportList(const struct RoseEngine *rose, u32 base_offset,
-                       u64a stream_offset, hs_scratch_t *scratch) {
-    DEBUG_PRINTF("running report list at offset %u\n", base_offset);
-
-    if (told_to_stop_matching(scratch)) {
-        DEBUG_PRINTF("matching has been terminated\n");
-        return;
-    }
-
-    if (rose->hasSom && scratch->deduper.current_report_offset == ~0ULL) {
-        /* we cannot delay the initialization of the som deduper logs any longer
-         * as we are reporting matches. This is done explicitly as we are
-         * shortcutting the som handling in the vacuous repeats as we know they
-         * all come from non-som patterns. */
-
-        fatbit_clear(scratch->deduper.som_log[0]);
-        fatbit_clear(scratch->deduper.som_log[1]);
-        scratch->deduper.som_log_dirty = 0;
-    }
-
-    const ReportID *report =
-        (const ReportID *)((const char *)rose + base_offset);
-
-    /* never required to do som as vacuous reports are always external */
-
-    if (rose->simpleCallback) {
-        for (; *report != MO_INVALID_IDX; report++) {
-            roseSimpleAdaptor(stream_offset, *report, scratch);
-        }
-    } else {
-        for (; *report != MO_INVALID_IDX; report++) {
-            roseAdaptor(stream_offset, *report, scratch);
-        }
-    }
+void setStreamStatus(char *state, u8 status) {
+    assert((status & ~STATUS_VALID_BITS) == 0);
+    *(u8 *)state = status;
 }
 
 /** \brief Initialise SOM state. Used in both block and streaming mode. */
 static really_inline
-void initSomState(const struct RoseEngine *rose, u8 *state) {
+void initSomState(const struct RoseEngine *rose, char *state) {
     assert(rose && state);
     const u32 somCount = rose->somLocationCount;
-    mmbit_clear(state + rose->stateOffsets.somValid, somCount);
-    mmbit_clear(state + rose->stateOffsets.somWritable, somCount);
+    mmbit_clear((u8 *)state + rose->stateOffsets.somValid, somCount);
+    mmbit_clear((u8 *)state + rose->stateOffsets.somWritable, somCount);
 }
 
 static really_inline
@@ -682,12 +179,11 @@ void rawBlockExec(const struct RoseEngine *rose, struct hs_scratch *scratch) {
     assert(rose);
     assert(scratch);
 
-    initSomState(rose, (u8 *)scratch->core_info.state);
+    initSomState(rose, scratch->core_info.state);
 
     DEBUG_PRINTF("blockmode scan len=%zu\n", scratch->core_info.len);
 
-    roseBlockExec(rose, scratch, selectAdaptor(rose),
-                  selectSomAdaptor(rose), scratch);
+    roseBlockExec(rose, scratch);
 }
 
 static really_inline
@@ -697,18 +193,18 @@ void pureLiteralBlockExec(const struct RoseEngine *rose,
     assert(scratch);
 
     const struct HWLM *ftable = getFLiteralMatcher(rose);
-    initSomState(rose, (u8 *)scratch->core_info.state);
+    initSomState(rose, scratch->core_info.state);
     const u8 *buffer = scratch->core_info.buf;
     size_t length = scratch->core_info.len;
     DEBUG_PRINTF("rose engine %d\n", rose->runtimeImpl);
 
-    hwlmExec(ftable, buffer, length, 0, selectHwlmAdaptor(rose), scratch,
+    hwlmExec(ftable, buffer, length, 0, rosePureLiteralCallback, scratch,
              rose->initialGroups);
 }
 
 static really_inline
-void initQueue(struct mq *q, u32 qi, const struct RoseEngine *t,
-               struct hs_scratch *scratch) {
+void initOutfixQueue(struct mq *q, u32 qi, const struct RoseEngine *t,
+                     struct hs_scratch *scratch) {
     const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
     q->nfa = getNfaByInfo(t, info);
     q->end = 0;
@@ -720,8 +216,8 @@ void initQueue(struct mq *q, u32 qi, const struct RoseEngine *t,
     q->length = scratch->core_info.len;
     q->history = scratch->core_info.hbuf;
     q->hlength = scratch->core_info.hlen;
-    q->cb = selectAdaptor(t);
-    q->som_cb = selectSomAdaptor(t);
+    q->cb = roseReportAdaptor;
+    q->som_cb = roseReportSomAdaptor;
     q->context = scratch;
     q->report_current = 0;
 
@@ -736,7 +232,7 @@ void soleOutfixBlockExec(const struct RoseEngine *t,
     assert(t);
     assert(scratch);
 
-    initSomState(t, (u8 *)scratch->core_info.state);
+    initSomState(t, scratch->core_info.state);
     assert(t->outfixEndQueue == 1);
     assert(!t->amatcherOffset);
     assert(!t->ematcherOffset);
@@ -751,7 +247,7 @@ void soleOutfixBlockExec(const struct RoseEngine *t,
     }
 
     struct mq *q = scratch->queues;
-    initQueue(q, 0, t, scratch);
+    initOutfixQueue(q, 0, t, scratch);
     q->length = len; /* adjust for rev_accel */
     nfaQueueInitState(nfa, q);
     pushQueueAt(q, 0, MQE_START, 0);
@@ -784,18 +280,16 @@ void runSmallWriteEngine(const struct SmallWriteEngine *smwr,
 
     const struct NFA *nfa = getSmwrNfa(smwr);
 
-    const struct RoseEngine *rose = scratch->core_info.rose;
-
     size_t local_alen = length - smwr->start_offset;
     const u8 *local_buffer = buffer + smwr->start_offset;
 
     assert(isMcClellanType(nfa->type));
     if (nfa->type == MCCLELLAN_NFA_8) {
         nfaExecMcClellan8_B(nfa, smwr->start_offset, local_buffer,
-                            local_alen, selectAdaptor(rose), scratch);
+                            local_alen, roseReportAdaptor, scratch);
     } else {
         nfaExecMcClellan16_B(nfa, smwr->start_offset, local_buffer,
-                             local_alen, selectAdaptor(rose), scratch);
+                             local_alen, roseReportAdaptor, scratch);
     }
 }
 
@@ -825,8 +319,13 @@ hs_error_t hs_scan(const hs_database_t *db, const char *data, unsigned length,
         return HS_INVALID;
     }
 
+    if (unlikely(markScratchInUse(scratch))) {
+        return HS_SCRATCH_IN_USE;
+    }
+
     if (rose->minWidth > length) {
         DEBUG_PRINTF("minwidth=%u > length=%u\n", rose->minWidth, length);
+        unmarkScratchInUse(scratch);
         return HS_SUCCESS;
     }
 
@@ -834,20 +333,24 @@ hs_error_t hs_scan(const hs_database_t *db, const char *data, unsigned length,
 
     /* populate core info in scratch */
     populateCoreInfo(scratch, rose, scratch->bstate, onEvent, userCtx, data,
-                     length, NULL, 0, 0, flags);
+                     length, NULL, 0, 0, 0, flags);
 
-    clearEvec(scratch->core_info.exhaustionVector, rose);
+    clearEvec(rose, scratch->core_info.exhaustionVector);
 
     if (!length) {
         if (rose->boundary.reportZeroEodOffset) {
-            processReportList(rose, rose->boundary.reportZeroEodOffset, 0,
-                              scratch);
+            roseRunBoundaryProgram(rose, rose->boundary.reportZeroEodOffset, 0,
+                                   scratch);
         }
         goto set_retval;
     }
 
     if (rose->boundary.reportZeroOffset) {
-        processReportList(rose, rose->boundary.reportZeroOffset, 0, scratch);
+        int rv = roseRunBoundaryProgram(rose, rose->boundary.reportZeroOffset,
+                                        0, scratch);
+        if (rv == MO_HALT_MATCHING) {
+            goto set_retval;
+        }
     }
 
     if (rose->minWidthExcludingBoundaries > length) {
@@ -896,24 +399,30 @@ hs_error_t hs_scan(const hs_database_t *db, const char *data, unsigned length,
 
 done_scan:
     if (told_to_stop_matching(scratch)) {
+        unmarkScratchInUse(scratch);
         return HS_SCAN_TERMINATED;
     }
 
     if (rose->hasSom) {
         int halt = flushStoredSomMatches(scratch, ~0ULL);
         if (halt) {
+            unmarkScratchInUse(scratch);
             return HS_SCAN_TERMINATED;
         }
     }
 
     if (rose->boundary.reportEodOffset) {
-        processReportList(rose, rose->boundary.reportEodOffset, length, scratch);
+        roseRunBoundaryProgram(rose, rose->boundary.reportEodOffset, length,
+                               scratch);
     }
 
 set_retval:
     DEBUG_PRINTF("done. told_to_stop_matching=%d\n",
                  told_to_stop_matching(scratch));
-    return told_to_stop_matching(scratch) ? HS_SCAN_TERMINATED : HS_SUCCESS;
+    hs_error_t rv = told_to_stop_matching(scratch) ? HS_SCAN_TERMINATED
+                                                   : HS_SUCCESS;
+    unmarkScratchInUse(scratch);
+    return rv;
 }
 
 static really_inline
@@ -951,14 +460,23 @@ void maintainHistoryBuffer(const struct RoseEngine *rose, char *state,
 
 static really_inline
 void init_stream(struct hs_stream *s, const struct RoseEngine *rose) {
+    char *state = getMultiState(s);
+
+    // Make absolutely sure that the 16 bytes leading up to the end of the
+    // history buffer are initialised, as we rely on this (regardless of the
+    // actual values used) in FDR.
+    char *hist_end = state + rose->stateOffsets.history + rose->historyRequired;
+    assert(hist_end - 16 >= (const char *)s);
+    unaligned_store_u64a(hist_end - 16, 0xDEADDEADDEADDEADull);
+    unaligned_store_u64a(hist_end - 8, 0xDEADDEADDEADDEADull);
+
     s->rose = rose;
     s->offset = 0;
 
-    u8 *state = (u8 *)getMultiState(s);
-
+    setStreamStatus(state, 0);
     roseInitState(rose, state);
 
-    clearEvec((char *)state + rose->stateOffsets.exhausted, rose);
+    clearEvec(rose, state + rose->stateOffsets.exhausted);
 
     // SOM state multibit structures.
     initSomState(rose, state);
@@ -1003,12 +521,9 @@ hs_error_t hs_open_stream(const hs_database_t *db, UNUSED unsigned flags,
 static really_inline
 void rawEodExec(hs_stream_t *id, hs_scratch_t *scratch) {
     const struct RoseEngine *rose = id->rose;
-    char *state = getMultiState(id);
-    u8 broken = getBroken(state);
 
-    if (broken) {
+    if (can_stop_matching(scratch)) {
         DEBUG_PRINTF("stream already broken\n");
-        assert(broken == BROKEN_FROM_USER || broken == BROKEN_EXHAUSTED);
         return;
     }
 
@@ -1017,19 +532,15 @@ void rawEodExec(hs_stream_t *id, hs_scratch_t *scratch) {
         return;
     }
 
-    roseEodExec(rose, (u8 *)state, id->offset, scratch, selectAdaptor(rose),
-                selectSomAdaptor(rose), scratch);
+    roseEodExec(rose, id->offset, scratch);
 }
 
 static never_inline
 void soleOutfixEodExec(hs_stream_t *id, hs_scratch_t *scratch) {
     const struct RoseEngine *t = id->rose;
-    char *state = getMultiState(id);
-    u8 broken = getBroken(state);
 
-    if (broken) {
+    if (can_stop_matching(scratch)) {
         DEBUG_PRINTF("stream already broken\n");
-        assert(broken == BROKEN_FROM_USER || broken == BROKEN_EXHAUSTED);
         return;
     }
 
@@ -1046,7 +557,7 @@ void soleOutfixEodExec(hs_stream_t *id, hs_scratch_t *scratch) {
     const struct NFA *nfa = getNfaByQueue(t, 0);
 
     struct mq *q = scratch->queues;
-    initQueue(q, 0, t, scratch);
+    initOutfixQueue(q, 0, t, scratch);
     if (!scratch->core_info.buf_offset) {
         DEBUG_PRINTF("buf_offset is zero\n");
         return; /* no vacuous engines */
@@ -1068,15 +579,16 @@ void report_eod_matches(hs_stream_t *id, hs_scratch_t *scratch,
 
     const struct RoseEngine *rose = id->rose;
     char *state = getMultiState(id);
+    u8 status = getStreamStatus(state);
 
-    if (getBroken(state)) {
+    if (status & (STATUS_TERMINATED | STATUS_EXHAUSTED)) {
         DEBUG_PRINTF("stream is broken, just freeing storage\n");
         return;
     }
 
     populateCoreInfo(scratch, rose, state, onEvent, context, NULL, 0,
                      getHistory(state, rose, id->offset),
-                     getHistoryAmount(rose, id->offset), id->offset, 0);
+                     getHistoryAmount(rose, id->offset), id->offset, status, 0);
 
     if (rose->somLocationCount) {
         loadSomFromStream(scratch, id->offset);
@@ -1084,13 +596,19 @@ void report_eod_matches(hs_stream_t *id, hs_scratch_t *scratch,
 
     if (!id->offset) {
         if (rose->boundary.reportZeroEodOffset) {
-            processReportList(rose, rose->boundary.reportZeroEodOffset, 0,
-                              scratch);
+            int rv = roseRunBoundaryProgram(
+                rose, rose->boundary.reportZeroEodOffset, 0, scratch);
+            if (rv == MO_HALT_MATCHING) {
+                return;
+            }
         }
     } else {
         if (rose->boundary.reportEodOffset) {
-            processReportList(rose, rose->boundary.reportEodOffset,
-                              id->offset, scratch);
+            int rv = roseRunBoundaryProgram(
+                rose, rose->boundary.reportEodOffset, id->offset, scratch);
+            if (rv == MO_HALT_MATCHING) {
+                return;
+            }
         }
 
         if (rose->requiresEodCheck) {
@@ -1112,8 +630,7 @@ void report_eod_matches(hs_stream_t *id, hs_scratch_t *scratch,
         int halt = flushStoredSomMatches(scratch, ~0ULL);
         if (halt) {
             DEBUG_PRINTF("told to stop matching\n");
-            scratch->core_info.broken = BROKEN_FROM_USER;
-            DEBUG_PRINTF("broken = %hhd\n", scratch->core_info.broken);
+            scratch->core_info.status |= STATUS_TERMINATED;
         }
     }
 }
@@ -1167,7 +684,11 @@ hs_error_t hs_reset_and_copy_stream(hs_stream_t *to_id,
         if (!scratch || !validScratch(to_id->rose, scratch)) {
             return HS_INVALID;
         }
+        if (unlikely(markScratchInUse(scratch))) {
+            return HS_SCRATCH_IN_USE;
+        }
         report_eod_matches(to_id, scratch, onEvent, context);
+        unmarkScratchInUse(scratch);
     }
 
     size_t stateSize
@@ -1182,29 +703,19 @@ static really_inline
 void rawStreamExec(struct hs_stream *stream_state, struct hs_scratch *scratch) {
     assert(stream_state);
     assert(scratch);
-
-    char *state = getMultiState(stream_state);
-
-    u8 broken = getBroken(state);
-    if (unlikely(broken)) {
-        assert(broken == BROKEN_FROM_USER || broken == BROKEN_EXHAUSTED);
-        scratch->core_info.broken = broken;
-        return;
-    }
+    assert(!can_stop_matching(scratch));
 
     DEBUG_PRINTF("::: streaming rose ::: offset = %llu len = %zu\n",
                  stream_state->offset, scratch->core_info.len);
 
     const struct RoseEngine *rose = stream_state->rose;
     assert(rose);
-    u8 *rose_state = (u8 *)state;
-    roseStreamExec(rose, rose_state, scratch, selectAdaptor(rose),
-                   selectSomAdaptor(rose), scratch);
+    roseStreamExec(rose, scratch);
 
     if (!told_to_stop_matching(scratch) &&
         isAllExhausted(rose, scratch->core_info.exhaustionVector)) {
         DEBUG_PRINTF("stream exhausted\n");
-        scratch->core_info.broken = BROKEN_EXHAUSTED;
+        scratch->core_info.status |= STATUS_EXHAUSTED;
     }
 }
 
@@ -1213,16 +724,10 @@ void pureLiteralStreamExec(struct hs_stream *stream_state,
                            struct hs_scratch *scratch) {
     assert(stream_state);
     assert(scratch);
+    assert(!can_stop_matching(scratch));
 
     char *state = getMultiState(stream_state);
 
-    u8 broken = getBroken(state);
-    if (unlikely(broken)) {
-        assert(broken == BROKEN_FROM_USER || broken == BROKEN_EXHAUSTED);
-        scratch->core_info.broken = broken;
-        return;
-    }
-
     const struct RoseEngine *rose = stream_state->rose;
     const struct HWLM *ftable = getFLiteralMatcher(rose);
 
@@ -1230,7 +735,7 @@ void pureLiteralStreamExec(struct hs_stream *stream_state,
 
     u8 *hwlm_stream_state;
     if (rose->floatingStreamState) {
-        hwlm_stream_state = getFloatingMatcherState(rose, (u8 *)state);
+        hwlm_stream_state = getFloatingMatcherState(rose, state);
     } else {
         hwlm_stream_state = NULL;
     }
@@ -1242,13 +747,13 @@ void pureLiteralStreamExec(struct hs_stream *stream_state,
     // start the match region at zero.
     const size_t start = 0;
 
-    hwlmExecStreaming(ftable, scratch, len2, start, selectHwlmAdaptor(rose),
+    hwlmExecStreaming(ftable, scratch, len2, start, rosePureLiteralCallback,
                       scratch, rose->initialGroups, hwlm_stream_state);
 
     if (!told_to_stop_matching(scratch) &&
         isAllExhausted(rose, scratch->core_info.exhaustionVector)) {
         DEBUG_PRINTF("stream exhausted\n");
-        scratch->core_info.broken = BROKEN_EXHAUSTED;
+        scratch->core_info.status |= STATUS_EXHAUSTED;
     }
 }
 
@@ -1257,6 +762,7 @@ void soleOutfixStreamExec(struct hs_stream *stream_state,
                           struct hs_scratch *scratch) {
     assert(stream_state);
     assert(scratch);
+    assert(!can_stop_matching(scratch));
 
     const struct RoseEngine *t = stream_state->rose;
     assert(t->outfixEndQueue == 1);
@@ -1267,7 +773,7 @@ void soleOutfixStreamExec(struct hs_stream *stream_state,
     const struct NFA *nfa = getNfaByQueue(t, 0);
 
     struct mq *q = scratch->queues;
-    initQueue(q, 0, t, scratch);
+    initOutfixQueue(q, 0, t, scratch);
     if (!scratch->core_info.buf_offset) {
         nfaQueueInitState(nfa, q);
         pushQueueAt(q, 0, MQE_START, 0);
@@ -1283,7 +789,7 @@ void soleOutfixStreamExec(struct hs_stream *stream_state,
     if (nfaQueueExec(q->nfa, q, scratch->core_info.len)) {
         nfaQueueCompressState(nfa, q, scratch->core_info.len);
     } else if (!told_to_stop_matching(scratch)) {
-        scratch->core_info.broken = BROKEN_EXHAUSTED;
+        scratch->core_info.status |= STATUS_EXHAUSTED;
     }
 }
 
@@ -1292,20 +798,22 @@ hs_error_t hs_scan_stream_internal(hs_stream_t *id, const char *data,
                                    unsigned length, UNUSED unsigned flags,
                                    hs_scratch_t *scratch,
                                    match_event_handler onEvent, void *context) {
-    if (unlikely(!id || !scratch || !data || !validScratch(id->rose, scratch))) {
+    assert(id);
+    assert(scratch);
+
+    if (unlikely(!data)) {
         return HS_INVALID;
     }
 
     const struct RoseEngine *rose = id->rose;
     char *state = getMultiState(id);
 
-    u8 broken = getBroken(state);
-    if (broken) {
+    u8 status = getStreamStatus(state);
+    if (status & (STATUS_TERMINATED | STATUS_EXHAUSTED)) {
         DEBUG_PRINTF("stream is broken, halting scan\n");
-        if (broken == BROKEN_FROM_USER) {
+        if (status & STATUS_TERMINATED) {
             return HS_SCAN_TERMINATED;
         } else {
-            assert(broken == BROKEN_EXHAUSTED);
             return HS_SUCCESS;
         }
     }
@@ -1315,14 +823,13 @@ hs_error_t hs_scan_stream_internal(hs_stream_t *id, const char *data,
     // cases here.
     if (unlikely(length == 0)) {
         DEBUG_PRINTF("zero length block\n");
-        assert(getBroken(state) != BROKEN_FROM_USER);
         return HS_SUCCESS;
     }
 
     u32 historyAmount = getHistoryAmount(rose, id->offset);
     populateCoreInfo(scratch, rose, state, onEvent, context, data, length,
                      getHistory(state, rose, id->offset), historyAmount,
-                     id->offset, flags);
+                     id->offset, status, flags);
     assert(scratch->core_info.hlen <= id->offset
            && scratch->core_info.hlen <= rose->historyRequired);
 
@@ -1334,7 +841,18 @@ hs_error_t hs_scan_stream_internal(hs_stream_t *id, const char *data,
 
     if (!id->offset && rose->boundary.reportZeroOffset) {
         DEBUG_PRINTF("zero reports\n");
-        processReportList(rose, rose->boundary.reportZeroOffset, 0, scratch);
+        int rv = roseRunBoundaryProgram(rose, rose->boundary.reportZeroOffset,
+                                        0, scratch);
+        if (rv == MO_HALT_MATCHING) {
+            DEBUG_PRINTF("halting scan\n");
+            setStreamStatus(state, scratch->core_info.status);
+            if (told_to_stop_matching(scratch)) {
+                return HS_SCAN_TERMINATED;
+            } else {
+                assert(scratch->core_info.status & STATUS_EXHAUSTED);
+                return HS_SUCCESS;
+            }
+        }
     }
 
     switch (rose->runtimeImpl) {
@@ -1353,13 +871,14 @@ hs_error_t hs_scan_stream_internal(hs_stream_t *id, const char *data,
     if (rose->hasSom && !told_to_stop_matching(scratch)) {
         int halt = flushStoredSomMatches(scratch, ~0ULL);
         if (halt) {
-            setBroken(state, BROKEN_FROM_USER);
-            scratch->core_info.broken = BROKEN_FROM_USER;
+            scratch->core_info.status |= STATUS_TERMINATED;
         }
     }
 
+    setStreamStatus(state, scratch->core_info.status);
+
     if (likely(!can_stop_matching(scratch))) {
-        maintainHistoryBuffer(id->rose, getMultiState(id), data, length);
+        maintainHistoryBuffer(rose, state, data, length);
         id->offset += length; /* maintain offset */
 
         if (rose->somLocationCount) {
@@ -1367,8 +886,6 @@ hs_error_t hs_scan_stream_internal(hs_stream_t *id, const char *data,
         }
     } else if (told_to_stop_matching(scratch)) {
         return HS_SCAN_TERMINATED;
-    } else { /* exhausted */
-        setBroken(state, BROKEN_EXHAUSTED);
     }
 
     return HS_SUCCESS;
@@ -1378,8 +895,18 @@ HS_PUBLIC_API
 hs_error_t hs_scan_stream(hs_stream_t *id, const char *data, unsigned length,
                           unsigned flags, hs_scratch_t *scratch,
                           match_event_handler onEvent, void *context) {
-    return hs_scan_stream_internal(id, data, length, flags, scratch,
-                                       onEvent, context);
+    if (unlikely(!id || !scratch || !data ||
+                 !validScratch(id->rose, scratch))) {
+        return HS_INVALID;
+    }
+
+    if (unlikely(markScratchInUse(scratch))) {
+        return HS_SCRATCH_IN_USE;
+    }
+    hs_error_t rv = hs_scan_stream_internal(id, data, length, flags, scratch,
+                                            onEvent, context);
+    unmarkScratchInUse(scratch);
+    return rv;
 }
 
 HS_PUBLIC_API
@@ -1393,7 +920,11 @@ hs_error_t hs_close_stream(hs_stream_t *id, hs_scratch_t *scratch,
         if (!scratch || !validScratch(id->rose, scratch)) {
             return HS_INVALID;
         }
+        if (unlikely(markScratchInUse(scratch))) {
+            return HS_SCRATCH_IN_USE;
+        }
         report_eod_matches(id, scratch, onEvent, context);
+        unmarkScratchInUse(scratch);
     }
 
     hs_stream_free(id);
@@ -1413,7 +944,11 @@ hs_error_t hs_reset_stream(hs_stream_t *id, UNUSED unsigned int flags,
         if (!scratch || !validScratch(id->rose, scratch)) {
             return HS_INVALID;
         }
+        if (unlikely(markScratchInUse(scratch))) {
+            return HS_SCRATCH_IN_USE;
+        }
         report_eod_matches(id, scratch, onEvent, context);
+        unmarkScratchInUse(scratch);
     }
 
     init_stream(id, id->rose);
@@ -1495,6 +1030,10 @@ hs_error_t hs_scan_vector(const hs_database_t *db, const char * const * data,
         return HS_INVALID;
     }
 
+    if (unlikely(markScratchInUse(scratch))) {
+        return HS_SCRATCH_IN_USE;
+    }
+
     hs_stream_t *id = (hs_stream_t *)(scratch->bstate);
 
     init_stream(id, rose); /* open stream */
@@ -1509,6 +1048,7 @@ hs_error_t hs_scan_vector(const hs_database_t *db, const char * const * data,
             = hs_scan_stream_internal(id, data[i], length[i], 0, scratch,
                                       onEvent, context);
         if (ret != HS_SUCCESS) {
+            unmarkScratchInUse(scratch);
             return ret;
         }
     }
@@ -1518,9 +1058,12 @@ hs_error_t hs_scan_vector(const hs_database_t *db, const char * const * data,
         report_eod_matches(id, scratch, onEvent, context);
 
         if (told_to_stop_matching(scratch)) {
+            unmarkScratchInUse(scratch);
             return HS_SCAN_TERMINATED;
         }
     }
 
+    unmarkScratchInUse(scratch);
+
     return HS_SUCCESS;
 }
diff --git a/src/scratch.c b/src/scratch.c
index 7afe7ec8..d8742e7d 100644
--- a/src/scratch.c
+++ b/src/scratch.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -40,13 +40,32 @@
 #include "state.h"
 #include "ue2common.h"
 #include "database.h"
-#include "nfa/limex_context.h" // for NFAContext128 etc
 #include "nfa/nfa_api_queue.h"
-#include "sidecar/sidecar.h"
 #include "rose/rose_internal.h"
 #include "util/fatbit.h"
 #include "util/multibit.h"
 
+/**
+ * Determine the space required for a correctly aligned array of fatbit
+ * structure, laid out as:
+ *
+ * - an array of num_entries pointers, each to a fatbit.
+ * - an array of fatbit structures, each of size fatbit_size(num_keys).
+ */
+static
+size_t fatbit_array_size(u32 num_entries, u32 num_keys) {
+    size_t len = 0;
+
+    // Array of pointers to each fatbit entry.
+    len += sizeof(struct fatbit *) * num_entries;
+
+    // Fatbit entries themselves.
+    len = ROUNDUP_N(len, alignof(struct fatbit));
+    len += (size_t)fatbit_size(num_keys) * num_entries;
+
+    return ROUNDUP_N(len, 8); // Round up for potential padding.
+}
+
 /** Used by hs_alloc_scratch and hs_clone_scratch to allocate a complete
  * scratch region from a prototype structure. */
 static
@@ -56,8 +75,6 @@ hs_error_t alloc_scratch(const hs_scratch_t *proto, hs_scratch_t **scratch) {
     u32 bStateSize = proto->bStateSize;
     u32 tStateSize = proto->tStateSize;
     u32 fullStateSize = proto->fullStateSize;
-    u32 anchored_region_len = proto->anchored_region_len;
-    u32 anchored_region_width = proto->anchored_region_width;
     u32 anchored_literal_region_len = proto->anchored_literal_region_len;
     u32 anchored_literal_region_width = proto->anchored_literal_count;
 
@@ -71,38 +88,28 @@ hs_error_t alloc_scratch(const hs_scratch_t *proto, hs_scratch_t **scratch) {
     size_t queue_size = queueCount * sizeof(struct mq);
     size_t qmpq_size = queueCount * sizeof(struct queue_match);
 
-    assert(anchored_region_len < 8 * sizeof(s->am_log_sum));
-    assert(anchored_literal_region_len < 8 * sizeof(s->am_log_sum));
+    assert(anchored_literal_region_len < 8 * sizeof(s->al_log_sum));
 
-    size_t anchored_region_size = anchored_region_len
-        * (mmbit_size(anchored_region_width) + sizeof(u8 *));
-    anchored_region_size = ROUNDUP_N(anchored_region_size, 8);
-
-    size_t anchored_literal_region_size = anchored_literal_region_len
-        * (mmbit_size(anchored_literal_region_width) + sizeof(u8 *));
-    anchored_literal_region_size = ROUNDUP_N(anchored_literal_region_size, 8);
-
-    size_t delay_size = mmbit_size(proto->delay_count) * DELAY_SLOT_COUNT;
-
-    size_t nfa_context_size = 2 * sizeof(struct NFAContext512) + 127;
+    size_t anchored_literal_region_size = fatbit_array_size(
+        anchored_literal_region_len, anchored_literal_region_width);
+    size_t delay_region_size =
+        fatbit_array_size(DELAY_SLOT_COUNT, proto->delay_count);
 
     // the size is all the allocated stuff, not including the struct itself
     size_t size = queue_size + 63
                   + bStateSize + tStateSize
                   + fullStateSize + 63 /* cacheline padding */
-                  + nfa_context_size
-                  + fatbit_size(proto->roleCount) /* handled roles */
+                  + fatbit_size(proto->handledKeyCount) /* handled roles */
                   + fatbit_size(queueCount) /* active queue array */
                   + 2 * fatbit_size(deduperCount) /* need odd and even logs */
                   + 2 * fatbit_size(deduperCount) /* ditto som logs */
                   + 2 * sizeof(u64a) * deduperCount /* start offsets for som */
-                  + anchored_region_size
-                  + anchored_literal_region_size + qmpq_size + delay_size
+                  + anchored_literal_region_size + qmpq_size
+                  + delay_region_size
                   + som_store_size
                   + som_now_size
                   + som_attempted_size
-                  + som_attempted_store_size
-                  + proto->sideScratchSize + 15;
+                  + som_attempted_store_size + 15;
 
     /* the struct plus the allocated stuff plus padding for cacheline
      * alignment */
@@ -122,6 +129,7 @@ hs_error_t alloc_scratch(const hs_scratch_t *proto, hs_scratch_t **scratch) {
     *s = *proto;
 
     s->magic = SCRATCH_MAGIC;
+    s->in_use = 0;
     s->scratchSize = alloc_size;
     s->scratch_alloc = (char *)s_tmp;
 
@@ -142,23 +150,24 @@ hs_error_t alloc_scratch(const hs_scratch_t *proto, hs_scratch_t **scratch) {
     s->som_attempted_store = (u64a *)current;
     current += som_attempted_store_size;
 
-    s->delay_slots = (u8 *)current;
-    current += delay_size;
-
-    current = ROUNDUP_PTR(current, 8);
-    s->am_log = (u8 **)current;
-    current += sizeof(u8 *) * anchored_region_len;
-    for (u32 i = 0; i < anchored_region_len; i++) {
-        s->am_log[i] = (u8 *)current;
-        current += mmbit_size(anchored_region_width);
+    current = ROUNDUP_PTR(current, alignof(struct fatbit *));
+    s->delay_slots = (struct fatbit **)current;
+    current += sizeof(struct fatbit *) * DELAY_SLOT_COUNT;
+    current = ROUNDUP_PTR(current, alignof(struct fatbit));
+    for (u32 i = 0; i < DELAY_SLOT_COUNT; i++) {
+        s->delay_slots[i] = (struct fatbit *)current;
+        assert(ISALIGNED(s->delay_slots[i]));
+        current += fatbit_size(proto->delay_count);
     }
 
-    current = ROUNDUP_PTR(current, 8);
-    s->al_log = (u8 **)current;
-    current += sizeof(u8 *) * anchored_literal_region_len;
+    current = ROUNDUP_PTR(current, alignof(struct fatbit *));
+    s->al_log = (struct fatbit **)current;
+    current += sizeof(struct fatbit *) * anchored_literal_region_len;
+    current = ROUNDUP_PTR(current, alignof(struct fatbit));
     for (u32 i = 0; i < anchored_literal_region_len; i++) {
-        s->al_log[i] = (u8 *)current;
-        current += mmbit_size(anchored_literal_region_width);
+        s->al_log[i] = (struct fatbit *)current;
+        assert(ISALIGNED(s->al_log[i]));
+        current += fatbit_size(anchored_literal_region_width);
     }
 
     current = ROUNDUP_PTR(current, 8);
@@ -174,13 +183,6 @@ hs_error_t alloc_scratch(const hs_scratch_t *proto, hs_scratch_t **scratch) {
     current += tStateSize;
 
     current = ROUNDUP_PTR(current, 64);
-    assert(ISALIGNED_CL(current));
-    s->nfaContext = current;
-    current += sizeof(struct NFAContext512);
-    current = ROUNDUP_PTR(current, 64);
-    assert(ISALIGNED_CL(current));
-    s->nfaContextSom = current;
-    current += sizeof(struct NFAContext512);
 
     assert(ISALIGNED_N(current, 8));
     s->deduper.som_start_log[0] = (u64a *)current;
@@ -194,7 +196,7 @@ hs_error_t alloc_scratch(const hs_scratch_t *proto, hs_scratch_t **scratch) {
     current += fatbit_size(queueCount);
 
     s->handled_roles = (struct fatbit *)current;
-    current += fatbit_size(proto->roleCount);
+    current += fatbit_size(proto->handledKeyCount);
 
     s->deduper.log[0] = (struct fatbit *)current;
     current += fatbit_size(deduperCount);
@@ -214,10 +216,6 @@ hs_error_t alloc_scratch(const hs_scratch_t *proto, hs_scratch_t **scratch) {
     s->som_attempted_set = (struct fatbit *)current;
     current += som_attempted_size;
 
-    current = ROUNDUP_PTR(current, 16);
-    s->side_scratch = (void *)current;
-    current += proto->sideScratchSize;
-
     current = ROUNDUP_PTR(current, 64);
     assert(ISALIGNED_CL(current));
     s->fullState = (char *)current;
@@ -229,11 +227,6 @@ hs_error_t alloc_scratch(const hs_scratch_t *proto, hs_scratch_t **scratch) {
     // Don't get too big for your boots
     assert((size_t)(current - (char *)s) <= alloc_size);
 
-    // Init q->scratch ptr for every queue.
-    for (struct mq *qi = s->queues; qi != s->queues + queueCount; ++qi) {
-        qi->scratch = s;
-    }
-
     return HS_SUCCESS;
 }
 
@@ -262,6 +255,9 @@ hs_error_t hs_alloc_scratch(const hs_database_t *db, hs_scratch_t **scratch) {
         if ((*scratch)->magic != SCRATCH_MAGIC) {
             return HS_INVALID;
         }
+        if (markScratchInUse(*scratch)) {
+            return HS_SCRATCH_IN_USE;
+        }
     }
 
     const struct RoseEngine *rose = hs_get_bytecode(db);
@@ -287,22 +283,6 @@ hs_error_t hs_alloc_scratch(const hs_database_t *db, hs_scratch_t **scratch) {
     }
     proto->scratch_alloc = (char *)proto_tmp;
 
-    u32 max_anchored_match = rose->anchoredDistance;
-    if (max_anchored_match > rose->maxSafeAnchoredDROffset) {
-        u32 anchored_region_len = max_anchored_match
-            - rose->maxSafeAnchoredDROffset;
-        if (anchored_region_len > proto->anchored_region_len) {
-            resize = 1;
-            proto->anchored_region_len = anchored_region_len;
-        }
-    }
-
-    u32 anchored_region_width = rose->anchoredMatches;
-    if (anchored_region_width > proto->anchored_region_width) {
-        resize = 1;
-        proto->anchored_region_width = anchored_region_width;
-    }
-
     if (rose->anchoredDistance > proto->anchored_literal_region_len) {
         resize = 1;
         proto->anchored_literal_region_len = rose->anchoredDistance;
@@ -318,9 +298,9 @@ hs_error_t hs_alloc_scratch(const hs_database_t *db, hs_scratch_t **scratch) {
         proto->delay_count = rose->delay_count;
     }
 
-    if (rose->roleCount > proto->roleCount) {
+    if (rose->handledKeyCount > proto->handledKeyCount) {
         resize = 1;
-        proto->roleCount = rose->roleCount;
+        proto->handledKeyCount = rose->handledKeyCount;
     }
 
     if (rose->tStateSize > proto->tStateSize) {
@@ -328,12 +308,6 @@ hs_error_t hs_alloc_scratch(const hs_database_t *db, hs_scratch_t **scratch) {
         proto->tStateSize = rose->tStateSize;
     }
 
-    const struct sidecar *side = getSLiteralMatcher(rose);
-    if (side && sidecarScratchSize(side) > proto->sideScratchSize) {
-        resize = 1;
-        proto->sideScratchSize = sidecarScratchSize(side);
-    }
-
     u32 som_store_count = rose->somLocationCount;
     if (som_store_count > proto->som_store_count) {
         resize = 1;
@@ -383,8 +357,10 @@ hs_error_t hs_alloc_scratch(const hs_database_t *db, hs_scratch_t **scratch) {
         }
     } else {
         hs_scratch_free(proto_tmp); /* kill off temp used for sizing */
+        unmarkScratchInUse(*scratch);
     }
 
+    assert(!(*scratch)->in_use);
     return HS_SUCCESS;
 }
 
@@ -401,6 +377,7 @@ hs_error_t hs_clone_scratch(const hs_scratch_t *src, hs_scratch_t **dest) {
         return ret;
     }
 
+    assert(!(*dest)->in_use);
     return HS_SUCCESS;
 }
 
@@ -414,6 +391,10 @@ hs_error_t hs_free_scratch(hs_scratch_t *scratch) {
         if (scratch->magic != SCRATCH_MAGIC) {
             return HS_INVALID;
         }
+        if (markScratchInUse(scratch)) {
+            return HS_SCRATCH_IN_USE;
+        }
+
         scratch->magic = 0;
         assert(scratch->scratch_alloc);
         DEBUG_PRINTF("scratch %p is really at %p : freeing\n", scratch,
diff --git a/src/scratch.h b/src/scratch.h
index 83e76da3..f8e322f8 100644
--- a/src/scratch.h
+++ b/src/scratch.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -37,8 +37,6 @@
 #define SCRATCH_H_DA6D4FC06FF410
 
 #include "ue2common.h"
-#include "util/multibit_internal.h"
-#include "sidecar/sidecar_internal.h"
 #include "rose/rose_types.h"
 
 #ifdef __cplusplus
@@ -72,17 +70,16 @@ struct catchup_pq {
     u32 qm_size; /**< current size of the priority queue */
 };
 
+/** \brief Status flag: user requested termination. */
+#define STATUS_TERMINATED   (1U << 0)
 
-/** \brief Value indicating a stream is active (not broken). */
-#define NOT_BROKEN       0
+/** \brief Status flag: all possible matches on this stream have
+ * been raised (i.e. all its exhaustion keys are on.) */
+#define STATUS_EXHAUSTED    (1U << 1)
 
-/** \brief Value indicating that the user has requested that matching be
- * terminated. */
-#define BROKEN_FROM_USER 1
-
-/** \brief Value indicating that all possible matches on this stream have been
- * raised (i.e. all its exhaustion keys are on.) */
-#define BROKEN_EXHAUSTED 2
+/** \brief Status flag: Rose requires rebuild as delay literal matched in
+ * history. */
+#define STATUS_DELAY_DIRTY  (1U << 2)
 
 /** \brief Core information about the current scan, used everywhere. */
 struct core_info {
@@ -95,19 +92,16 @@ struct core_info {
     const struct RoseEngine *rose;
     char *state; /**< full stream state */
     char *exhaustionVector; /**< pointer to evec for this stream */
-    char broken;  /**< user told us to stop, or exhausted */
     const u8 *buf; /**< main scan buffer */
     size_t len; /**< length of main scan buffer in bytes */
     const u8 *hbuf; /**< history buffer */
     size_t hlen; /**< length of history buffer in bytes. */
     u64a buf_offset; /**< stream offset, for the base of the buffer */
+    u8 status; /**< stream status bitmask, using STATUS_ flags above */
 };
 
 /** \brief Rose state information. */
 struct RoseContext {
-    const struct RoseEngine *t;
-    u8 *state; /**< base pointer to the full state */
-    u8 depth;
     u8 mpv_inactive;
     u64a groups;
     u64a lit_offset_adjust; /**< offset to add to matches coming from hwlm */
@@ -125,20 +119,14 @@ struct RoseContext {
                                 * still allowed to report */
     u64a next_mpv_offset; /**< earliest offset that the MPV can next report a
                            * match, cleared if top events arrive */
-    RoseCallback cb;
-    RoseCallbackSom cb_som;
-    void *userCtx;
     u32 filledDelayedSlots;
-    u32 curr_anchored_loc;   /**< last read/written row */
-    u32 curr_row_offset; /**< last read/written entry */
-    u64a side_curr; /**< current location of the sidecar scan (abs offset) */
     u32 curr_qi;    /**< currently executing main queue index during
                      * \ref nfaQueueExec */
 };
 
 struct match_deduper {
     struct fatbit *log[2]; /**< even, odd logs */
-    struct fatbit *som_log[2]; /**< even, odd mmbit logs for som */
+    struct fatbit *som_log[2]; /**< even, odd fatbit logs for som */
     u64a *som_start_log[2]; /**< even, odd start offset logs for som */
     u32 log_size;
     u64a current_report_offset;
@@ -152,6 +140,7 @@ struct match_deduper {
  */
 struct ALIGN_CL_DIRECTIVE hs_scratch {
     u32 magic;
+    u8 in_use; /**< non-zero when being used by an API call. */
     char *scratch_alloc; /* user allocated scratch object */
     u32 queueCount;
     u32 bStateSize; /**< sizeof block mode states */
@@ -160,31 +149,23 @@ struct ALIGN_CL_DIRECTIVE hs_scratch {
     struct RoseContext tctxt;
     char *bstate; /**< block mode states */
     char *tstate; /**< state for transient roses */
-    char *qNfaState; /**< queued NFA temp state */
-    void *nfaContext; /**< use for your NFAContextNNN struct */
-    void *nfaContextSom; /**< use for your NFAContextNNN struct by som_runtime */
     char *fullState; /**< uncompressed NFA state */
     struct mq *queues;
     struct fatbit *aqa; /**< active queue array; fatbit of queues that are valid
                          * & active */
-    u8 *delay_slots;
-    u8 **am_log;
-    u8 **al_log;
-    u64a am_log_sum;
+    struct fatbit **delay_slots;
+    struct fatbit **al_log;
     u64a al_log_sum;
     struct catchup_pq catchup_pq;
     struct core_info core_info;
     struct match_deduper deduper;
-    u32 anchored_region_len;
-    u32 anchored_region_width;
     u32 anchored_literal_region_len;
     u32 anchored_literal_count;
     u32 delay_count;
     u32 scratchSize;
-    u32 sideScratchSize;
     u8 ALIGN_DIRECTIVE fdr_temp_buf[FDR_TEMP_BUF_SIZE];
-    u32 roleCount;
-    struct fatbit *handled_roles; /**< mmbit of ROLES (not states) already
+    u32 handledKeyCount;
+    struct fatbit *handled_roles; /**< fatbit of ROLES (not states) already
                                    * handled by this literal */
     u64a *som_store; /**< array of som locations */
     u64a *som_attempted_store; /**< array of som locations for fail stores */
@@ -195,41 +176,55 @@ struct ALIGN_CL_DIRECTIVE hs_scratch {
                             * location had been writable */
     u64a som_set_now_offset; /**< offset at which som_set_now represents */
     u32 som_store_count;
-    struct mmbit_sparse_state sparse_iter_state[MAX_SPARSE_ITER_STATES];
-    union sidecar_enabled_any ALIGN_CL_DIRECTIVE side_enabled;
-    struct sidecar_scratch *side_scratch;
 };
 
+/* array of fatbit ptr; TODO: why not an array of fatbits? */
 static really_inline
-struct hs_scratch *tctxtToScratch(struct RoseContext *tctxt) {
-    return (struct hs_scratch *)
-        ((char *)tctxt - offsetof(struct hs_scratch, tctxt));
-}
-
-static really_inline
-u8 **getAnchoredLog(struct hs_scratch *scratch) { /* array of mmbit ptr */
-    return scratch->am_log;
-}
-
-/* array of mmbit ptr; TODO: why not an array of mmbits? */
-static really_inline
-u8 **getAnchoredLiteralLog(struct hs_scratch *scratch) {
+struct fatbit **getAnchoredLiteralLog(struct hs_scratch *scratch) {
     return scratch->al_log;
 }
 
 static really_inline
-u8 *getDelaySlots(struct hs_scratch *scratch) {
+struct fatbit **getDelaySlots(struct hs_scratch *scratch) {
     return scratch->delay_slots;
 }
 
 static really_inline
 char told_to_stop_matching(const struct hs_scratch *scratch) {
-    return scratch->core_info.broken == BROKEN_FROM_USER;
+    return scratch->core_info.status & STATUS_TERMINATED;
 }
 
 static really_inline
 char can_stop_matching(const struct hs_scratch *scratch) {
-    return scratch->core_info.broken != NOT_BROKEN;
+    return scratch->core_info.status & (STATUS_TERMINATED | STATUS_EXHAUSTED);
+}
+
+/**
+ * \brief Mark scratch as in use.
+ *
+ * Returns non-zero if it was already in use, zero otherwise.
+ */
+static really_inline
+char markScratchInUse(struct hs_scratch *scratch) {
+    DEBUG_PRINTF("marking scratch as in use\n");
+    assert(scratch && scratch->magic == SCRATCH_MAGIC);
+    if (scratch->in_use) {
+        DEBUG_PRINTF("scratch already in use!\n");
+        return 1;
+    }
+    scratch->in_use = 1;
+    return 0;
+}
+
+/**
+ * \brief Mark scratch as no longer in use.
+ */
+static really_inline
+void unmarkScratchInUse(struct hs_scratch *scratch) {
+    DEBUG_PRINTF("marking scratch as not in use\n");
+    assert(scratch && scratch->magic == SCRATCH_MAGIC);
+    assert(scratch->in_use == 1);
+    scratch->in_use = 0;
 }
 
 #ifdef __cplusplus
diff --git a/src/scratch_dump.cpp b/src/scratch_dump.cpp
index 00e09a83..78a854bb 100644
--- a/src/scratch_dump.cpp
+++ b/src/scratch_dump.cpp
@@ -56,12 +56,6 @@ void dumpScratch(const struct hs_scratch *s, FILE *f) {
     fprintf(f, "  bStateSize           : %u bytes\n", s->bStateSize);
     fprintf(f, "  active queue array   : %u bytes\n",
             mmbit_size(s->queueCount));
-
-    size_t anchored_region_size =
-        s->anchored_region_len * mmbit_size(s->anchored_region_width) +
-        sizeof(u8 *) + mmbit_size(s->anchored_region_len);
-
-    fprintf(f, "  anchored region      : %zu bytes\n", anchored_region_size);
     fprintf(f, "  qmpq                 : %zu bytes\n",
             s->queueCount * sizeof(struct queue_match));
     fprintf(f, "  delay info           : %u bytes\n",
diff --git a/src/sidecar/sidecar.c b/src/sidecar/sidecar.c
deleted file mode 100644
index 0abab06d..00000000
--- a/src/sidecar/sidecar.c
+++ /dev/null
@@ -1,349 +0,0 @@
-/*
- * Copyright (c) 2015, Intel Corporation
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of Intel Corporation nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "sidecar.h"
-#include "sidecar_internal.h"
-#include "sidecar_shufti.h"
-#include "ue2common.h"
-#include "nfa/vermicelli.h"
-#include "util/bitutils.h"
-#include "util/uniform_ops.h"
-
-static really_inline
-u32 findAndClearLSB_8(u8 *v) {
-    u32 t = *v;
-    u32 rv = findAndClearLSB_32(&t);
-    *v = t;
-    return rv;
-}
-
-static really_inline
-u32 findAndClearLSB_128(m128 *v) {
-    union {
-        u32 words[sizeof(m128)/sizeof(u32)];
-        m128 simd;
-    } s;
-    s.simd = *v;
-    u32 rv = 0;
-    for (u32 i = 0; i < ARRAY_LENGTH(s.words); i++) {
-        u32 *w = &s.words[i];
-        if (*w) {
-            rv = findAndClearLSB_32(w) + 32 * i;
-            break;
-        }
-    }
-
-    *v = s.simd;
-    return rv;
-}
-
-static never_inline
-u32 findAndClearLSB_256(m256 *v) {
-    union {
-        u32 words[sizeof(m256)/sizeof(u32)];
-        m256 simd;
-    } s;
-    s.simd = *v;
-    u32 rv = 0;
-    for (u32 i = 0; i < ARRAY_LENGTH(s.words); i++) {
-        u32 *w = &s.words[i];
-        if (*w) {
-            rv = findAndClearLSB_32(w) + 32 * i;
-            break;
-        }
-    }
-
-    *v = s.simd;
-    return rv;
-}
-
-#define DO_DEAD_CHECK 1
-
-#define TAG 8
-#define STATE_T u8
-#include "sidecar_generic.h"
-
-#define TAG 32
-#define STATE_T u32
-#include "sidecar_generic.h"
-
-#define TAG 64
-#define STATE_T u64a
-#include "sidecar_generic.h"
-
-#define TAG 128
-#define STATE_T m128
-#include "sidecar_generic.h"
-
-#define TAG 256
-#define STATE_T m256
-#include "sidecar_generic.h"
-
-
-static never_inline
-void sidecarExec_N(const struct sidecar_N *n, const u8 *b, size_t len,
-                   struct sidecar_enabled_N *enabled,
-                   UNUSED struct sidecar_scratch *scratch,
-                   u64a base_offset, SidecarCallback cb, void *context) {
-    DEBUG_PRINTF("N: %hhu %hhu nc %hhu\n", n->c, b[0], n->nocase);
-    if (!enabled->bits) {
-        return;
-    }
-
-    const u8 *loc = vermicelliExec(n->c, n->nocase, b, b + len);
-
-    if (loc == b + len) {
-        return;
-    }
-
-    enabled->bits = 0;
-    for (u32 i = 0; i < n->report_count; i++) {
-        cb(loc - b + base_offset, n->reports[i], context);
-    }
-}
-
-static really_inline
-void sidecarEnabledInit_N(struct sidecar_enabled *enabled) {
-    struct sidecar_enabled_N *e = (void *)enabled;
-    e->bits = 0;
-}
-
-static really_inline
-void sidecarExec_i_S(UNUSED const struct sidecar_S *n,
-                     UNUSED const u8 *b, UNUSED size_t len,
-                     UNUSED struct sidecar_enabled_S *enabled,
-                     UNUSED u64a base_offset, UNUSED SidecarCallback cb,
-                     UNUSED void *context) {
-    if (!enabled->bits) {
-        DEBUG_PRINTF("bail early, bail often\n");
-        return;
-    }
-
-    u8 state;
-    if (len >= 16) {
-        state = sidecarExec_S_int(n, b, len, enabled->bits);
-    } else {
-        const u8 *lo = (const u8 *)&n->lo;
-        const u8 *hi = (const u8 *)&n->hi;
-        state = enabled->bits;
-        for (u32 i = 0; i < len; i++) {
-            u8 c = b[i];
-            state &= lo[c & 0xf] | hi[c >> 4];
-        }
-    }
-
-    state = ~state & enabled->bits;
-    if (!state) {
-        DEBUG_PRINTF("bail\n");
-        return;
-    }
-
-    enabled->bits &= ~state;
-    DEBUG_PRINTF("s = %02hhx e = %02hhx\n", state, enabled->bits);
-    u8 unshared = n->unshared_mask;
-    const u8 *masks = sidecar_ids_to_mask_const(n);
-    const struct sidecar_id_offset *id_map = n->id_list;
-    while (state) {
-        u32 bit = findAndClearLSB_8(&state);
-        DEBUG_PRINTF("found bit %u\n", bit);
-        const u32 *id_base = (const u32 *)((const char *)n
-                                           + id_map[bit].first_offset);
-        u32 count = id_map[bit].count;
-        for (u32 i = 0; i < count; ++i) {
-            DEBUG_PRINTF("firing %u\n", id_base[i]);
-            cb(base_offset, id_base[i], context);
-            enabled->bits &= ~(masks[id_base[i]] & unshared);
-        }
-    }
-    DEBUG_PRINTF("s = %02hhx e = %02hhx\n", state, enabled->bits);
-}
-
-static really_inline
-void sidecarEnabledInit_S(struct sidecar_enabled *enabled) {
-    struct sidecar_enabled_S *e = (void *)enabled;
-    e->bits = 0;
-}
-
-static never_inline
-void sidecarExec_S(const struct sidecar_S *n, const u8 *b, size_t len,
-                   struct sidecar_enabled_S *enabled,
-                   UNUSED struct sidecar_scratch *scratch,
-                   u64a base_offset, SidecarCallback cb, void *context) {
-    if (len > 1) {
-        sidecarExec_i_S(n, b + 1, len - 1, enabled, base_offset + 1, cb,
-                        context);
-    }
-
-    u8 bits = enabled->bits; /* first byte doesn't change enabled */
-    sidecarExec_i_S(n, b, 1, enabled, base_offset, cb, context);
-    enabled->bits = bits;
-}
-
-void sidecarExec(const struct sidecar *n, const u8 *buffer, size_t len,
-                 struct sidecar_enabled *enabled,
-                 UNUSED struct sidecar_scratch *scratch, u64a base_offset,
-                 SidecarCallback cb, void *ctxt) {
-    assert(n);
-    assert(enabled);
-    assert(len);
-
-    assert(ISALIGNED_N(n, 16));
-    assert(ISALIGNED_N(scratch, 16));
-
-    if (!len) {
-        return;
-    }
-
-#define EXEC_CASE(tag) \
-    case SIDECAR_##tag:                                                 \
-        sidecarExec_##tag((const struct sidecar_##tag *)n, buffer,  len, \
-                          (struct sidecar_enabled_##tag *)enabled, scratch, \
-                          base_offset, cb, ctxt);                       \
-        break;
-
-    switch(n->type) {
-        EXEC_CASE(8)
-        EXEC_CASE(32)
-        EXEC_CASE(64)
-        EXEC_CASE(128)
-        EXEC_CASE(256)
-        EXEC_CASE(N)
-        EXEC_CASE(S)
-    default:
-        assert(0);
-    }
-
-#undef EXEC_CASE
-}
-
-void sidecarEnabledInit(const struct sidecar *n,
-                        struct sidecar_enabled *enabled) {
-    switch(n->type) {
-    case SIDECAR_8:
-        sidecarEnabledInit_8(enabled);
-        break;
-    case SIDECAR_32:
-        sidecarEnabledInit_32(enabled);
-        break;
-    case SIDECAR_64:
-        sidecarEnabledInit_64(enabled);
-        break;
-    case SIDECAR_128:
-        sidecarEnabledInit_128(enabled);
-        break;
-    case SIDECAR_256:
-        sidecarEnabledInit_256(enabled);
-        break;
-    case SIDECAR_N:
-        sidecarEnabledInit_N(enabled);
-        break;
-    case SIDECAR_S:
-        sidecarEnabledInit_S(enabled);
-        break;
-    default:
-        assert(0);
-    }
-}
-
-u32 sidecarScratchSize(const struct sidecar *n) {
-    u32 width;
-
-    switch(n->type) {
-    case SIDECAR_8:
-        width = sizeof(struct sidecar_mr_8);
-        break;
-    case SIDECAR_32:
-        width = sizeof(struct sidecar_mr_32);
-        break;
-    case SIDECAR_64:
-        width = sizeof(struct sidecar_mr_64);
-        break;
-    case SIDECAR_128:
-        width = sizeof(struct sidecar_mr_128);
-        break;
-    case SIDECAR_256:
-        width = sizeof(struct sidecar_mr_256);
-        break;
-    case SIDECAR_N:
-        return 0; /* no scratch required for N */
-    case SIDECAR_S:
-        width = sizeof(struct sidecar_mr_8);
-        break;
-    default:
-        assert(0);
-        return 0;
-    }
-
-    /* + 1, for first byte offset */
-    return width * (n->mask_bit_count + 1);
-}
-
-static really_inline
-void sidecarEnabledUnion_N(struct sidecar_enabled *dest,
-                           const struct sidecar_enabled *src) {
-    struct sidecar_enabled_N *d = (void *)dest;
-    const struct sidecar_enabled_N *s = (const void *)src;
-    d->bits |= s->bits;
-}
-
-static really_inline
-void sidecarEnabledUnion_S(struct sidecar_enabled *dest,
-                           const struct sidecar_enabled *src) {
-    struct sidecar_enabled_S *d = (void *)dest;
-    const struct sidecar_enabled_S *s = (const void *)src;
-    d->bits |= s->bits;
-}
-
-void sidecarEnabledUnion(const struct sidecar *n, struct sidecar_enabled *dest,
-                         const struct sidecar_enabled *src) {
-    switch(n->type) {
-    case SIDECAR_8:
-        sidecarEnabledUnion_8(dest, src);
-        break;
-    case SIDECAR_32:
-        sidecarEnabledUnion_32(dest, src);
-        break;
-    case SIDECAR_64:
-        sidecarEnabledUnion_64(dest, src);
-        break;
-    case SIDECAR_128:
-        sidecarEnabledUnion_128(dest, src);
-        break;
-    case SIDECAR_256:
-        sidecarEnabledUnion_256(dest, src);
-        break;
-    case SIDECAR_N:
-        sidecarEnabledUnion_N(dest, src);
-        break;
-    case SIDECAR_S:
-        sidecarEnabledUnion_S(dest, src);
-        break;
-    default:
-        assert(0);
-    }
-}
diff --git a/src/sidecar/sidecar_compile.cpp b/src/sidecar/sidecar_compile.cpp
deleted file mode 100644
index 30ac032e..00000000
--- a/src/sidecar/sidecar_compile.cpp
+++ /dev/null
@@ -1,600 +0,0 @@
-/*
- * Copyright (c) 2015, Intel Corporation
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of Intel Corporation nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "sidecar_compile.h"
-#include "sidecar_internal.h"
-#include "ue2common.h"
-#include "nfa/shufticompile.h"
-#include "util/alloc.h"
-#include "util/charreach.h"
-#include "util/simd_utils.h"
-#include "util/verify_types.h"
-
-#include <array>
-#include <map>
-#include <set>
-
-#include <boost/range/adaptor/map.hpp>
-
-using namespace std;
-using boost::adaptors::map_values;
-using boost::adaptors::map_keys;
-
-namespace ue2 {
-
-static
-void prune(array<set<u32>, N_CHARS> &by_char, u32 p,
-           map<CharReach, set<u32>> *impl_classes) {
-    CharReach cr;
-    assert(!by_char[p].empty());
-
-    for (u32 i = 0; i < N_CHARS; i++) {
-        if (by_char[i] == by_char[p]) {
-            cr.set(i);
-        }
-    }
-
-    assert(impl_classes->find(cr) == impl_classes->end());
-    (*impl_classes)[cr] = by_char[p];
-
-    for (size_t i = cr.find_first(); i != cr.npos; i = cr.find_next(i)) {
-        by_char[i].clear();
-    }
-
-}
-
-static really_inline
-void set_bit(u8 *a, size_t i) {
-    assert(i < 8);
-    *a |= 1U << i;
-}
-
-static really_inline
-void set_bit(u32 *a, size_t i) {
-    assert(i < 32);
-    *a |= 1U << i;
-}
-
-static really_inline
-void set_bit(u64a *a, size_t i) {
-    assert(i < 64);
-    *a |= 1ULL << i;
-}
-
-static really_inline
-void set_bit(m128 *a, size_t i) {
-    setbit128(a, i);
-}
-
-static really_inline
-void set_bit(m256 *a, size_t i) {
-    setbit256(a, i);
-}
-
-template<typename s>
-static really_inline
-void flip(s *v) {
-    *v = ~*v;
-}
-
-static really_inline
-void flip(m128 *v) {
-    *v = not128(*v);
-}
-
-static really_inline
-void flip(m256 *v) {
-    *v = not256(*v);
-}
-
-template<typename s>
-static really_inline
-void or_into_mask(s *a, const s b) {
-    *a |= b;
-}
-
-static really_inline
-void or_into_mask(m128 *a, const m128 b) {
-    *a = or128(*a, b);
-}
-
-static really_inline
-void or_into_mask(m256 *a, const m256 b) {
-    *a = or256(*a, b);
-}
-
-template<u8 s_type> struct sidecar_traits { };
-#define MAKE_TRAITS(type_id, base_type_in, mask_bits) \
-    template<> struct sidecar_traits<type_id> {       \
-        typedef base_type_in base_type;               \
-        static const u32 bits = mask_bits;            \
-        typedef sidecar_##mask_bits impl_type;        \
-        typedef sidecar_enabled_##mask_bits enabled_type;  \
-    };
-
-MAKE_TRAITS(SIDECAR_8,   u8,   8)
-MAKE_TRAITS(SIDECAR_32,  u32,  32)
-MAKE_TRAITS(SIDECAR_64,  u64a, 64)
-MAKE_TRAITS(SIDECAR_128, m128, 128)
-MAKE_TRAITS(SIDECAR_256, m256, 256)
-
-template<> struct sidecar_traits<SIDECAR_N> {
-    typedef sidecar_N impl_type;
-};
-
-template<> struct sidecar_traits<SIDECAR_S> {
-    typedef u8 base_type;
-    typedef sidecar_S impl_type;
-};
-
-/* builds the main char reach table */
-template <u8 s_type>
-static
-void populateTable(const map<CharReach, set<u32>> &impl_classes,
-                   typename sidecar_traits<s_type>::impl_type *ns) {
-    assert(impl_classes.size()
-           <= sizeof(typename sidecar_traits<s_type>::base_type) * 8);
-
-    u32 b = 0;
-    for (const CharReach &cr : impl_classes | map_keys) {
-        for (size_t i = cr.find_first(); i != cr.npos; i = cr.find_next(i)) {
-            set_bit(&ns->reach[i], b);
-        }
-        b++;
-    }
-
-    for (u32 i = 0; i < N_CHARS; i++) {
-        flip(&ns->reach[i]);
-    }
-}
-
-/* builds the table controlling which bits in the mask to turn on for each
- * external id */
-template <u8 s_type>
-static
-void populateIdMasks(const map<CharReach, set<u32>> &impl_classes,
-                     typename sidecar_traits<s_type>::impl_type *ns) {
-    typedef typename sidecar_traits<s_type>::base_type base;
-    base *table = (base *)((char *)ns + sizeof(*ns));
-    u32 b = 0;
-    for (const set<u32> &id_list : impl_classes | map_values) {
-        for (const u32 id : id_list) {
-            set_bit(&table[id], b);
-        }
-        if (id_list.size() == 1) {
-            set_bit(&ns->unshared_mask, b);
-        }
-        b++;
-    }
-}
-
-/* builds the lists of ids to report for each set bit */
-template <u8 s_type>
-static
-void populateMaskInfo(const map<CharReach, set<u32>> &impl_classes,
-                      u32 num_ext_classes,
-                      typename sidecar_traits<s_type>::impl_type *ns,
-                      sidecar_id_offset *mask_info) {
-    typedef typename sidecar_traits<s_type>::base_type base;
-
-    u32 *curr_ptr = (u32 *)((char *)ns + sizeof(*ns)
-                            + sizeof(base) * num_ext_classes);
-    curr_ptr = ROUNDUP_PTR(curr_ptr, sizeof(u32));
-
-    u32 b = 0;
-    for (const set<u32> &id_list : impl_classes | map_values) {
-        mask_info[b].first_offset = verify_u32((char *)curr_ptr - (char *)ns);
-        mask_info[b].count = verify_u32(id_list.size());
-        for (const u32 id : id_list) {
-            *curr_ptr = id;
-            curr_ptr++;
-        }
-        b++;
-    }
-}
-
-static
-size_t calcIdListSize(const map<CharReach, set<u32>> &impl_classes) {
-    size_t id_count = 0;
-    for (const auto &id_list : impl_classes | map_values) {
-        id_count += id_list.size();
-    }
-
-    return id_count * sizeof(u32);
-}
-
-template<u8 s_type>
-static
-aligned_unique_ptr<sidecar> construct(const vector<CharReach> &ext_classes,
-                   const map<CharReach, set<u32> > &impl_classes_in,
-                   bool allow_collapse) {
-    if (impl_classes_in.size() > sidecar_traits<s_type>::bits) {
-        return nullptr;
-    }
-
-    map<CharReach, set<u32>> impl_classes_loc;
-    const map<CharReach, set<u32>> *impl_classes;
-
-    if (ext_classes.size() <= sidecar_traits<s_type>::bits) {
-        /* we can directly map internal bits to external ids; no need for
-         * indirection */
-        for (u32 i = 0; i < ext_classes.size(); i++) {
-            impl_classes_loc[ext_classes[i]].insert(i);
-        }
-
-        impl_classes = &impl_classes_loc;
-    } else {
-        /* TODO: spread classes out if possible */
-        if (!allow_collapse) {
-            return nullptr;
-        }
-        impl_classes = &impl_classes_in;
-    }
-
-    typedef typename sidecar_traits<s_type>::base_type base;
-    typedef typename sidecar_traits<s_type>::impl_type impl;
-
-    u32 id_count = verify_u32(ext_classes.size());
-    size_t total_id_list_size = calcIdListSize(*impl_classes);
-    size_t size = sizeof(impl) + id_count * sizeof(base); /* ids -> masks */
-    size = ROUNDUP_N(size, sizeof(u32));
-    size += total_id_list_size;
-    DEBUG_PRINTF("allocated %zu\n", size);
-
-    auto s = aligned_zmalloc_unique<sidecar>(size);
-    assert(s); // otherwise we would have thrown std::bad_alloc
-    impl *ns = (impl *)(s.get());
-
-    ns->header.type = s_type;
-    ns->header.size = size;
-    ns->header.id_count = id_count;
-    ns->header.mask_bit_count = verify_u32(impl_classes->size());
-
-    populateTable<s_type>(*impl_classes, ns);
-    populateIdMasks<s_type>(*impl_classes, ns);
-    populateMaskInfo<s_type>(*impl_classes, id_count, ns, ns->id_list);
-
-    return s;
-}
-
-static
-bool isNoodable(const CharReach &cr) {
-    return cr.count() == 1 || (cr.count() == 2 && cr.isBit5Insensitive());
-}
-
-template <>
-aligned_unique_ptr<sidecar>
-construct<SIDECAR_N>(const vector<CharReach> &ext_classes,
-                     const map<CharReach, set<u32>> &impl_classes,
-                     bool) {
-    if (impl_classes.size() != 1 || !isNoodable(impl_classes.begin()->first)) {
-        return nullptr;
-    }
-
-    const CharReach &cr = impl_classes.begin()->first;
-    const set<u32> &reports = impl_classes.begin()->second;
-
-    u32 id_count = verify_u32(ext_classes.size());
-    size_t size = sizeof(sidecar_N) + sizeof(u32) * reports.size();
-    DEBUG_PRINTF("allocated %zu\n", size);
-
-    auto s = aligned_zmalloc_unique<sidecar>(size);
-    assert(s); // otherwise we would have thrown std::bad_alloc
-    sidecar_N *ns = (sidecar_N *)(s.get());
-
-    ns->header.type = SIDECAR_N;
-    ns->header.size = size;
-    ns->header.id_count = id_count;
-    ns->header.mask_bit_count = verify_u32(impl_classes.size());
-
-    ns->c = cr.find_first();
-    ns->nocase = cr.isBit5Insensitive();
-
-    ns->report_count = verify_u32(reports.size());
-    u32 *p = ns->reports;
-    for (u32 report : reports) {
-        *p = report;
-    }
-
-    return s;
-}
-
-static
-void flipShuftiMask(m128 *a) {
-    *a = not128(*a);
-}
-
-template <>
-aligned_unique_ptr<sidecar>
-construct<SIDECAR_S>(const vector<CharReach> &ext_classes,
-                     const map<CharReach, set<u32>> &impl_classes,
-                     bool) {
-    u32 id_count = verify_u32(ext_classes.size());
-    size_t total_id_list_size = calcIdListSize(impl_classes);
-    size_t size = sizeof(sidecar_S)
-        + id_count * sizeof(u8); /* ids -> masks */
-    size = ROUNDUP_N(size, sizeof(u32));
-    size += total_id_list_size;
-    DEBUG_PRINTF("allocated %zu\n", size);
-
-    auto s = aligned_zmalloc_unique<sidecar>(size);
-    assert(s); // otherwise we would have thrown std::bad_alloc
-    sidecar_S *ns = (sidecar_S *)(s.get());
-
-    ns->header.type = SIDECAR_S;
-    ns->header.size = size;
-    ns->header.id_count = id_count;
-
-    vector<const CharReach *> shuf_bit_to_impl;
-
-    /* populate the shufti masks */
-    u32 used_bits = 0;
-    for (const CharReach &cr : impl_classes | map_keys) {
-        m128 lo, hi;
-        int bits = shuftiBuildMasks(cr, &lo, &hi);
-
-        if (bits < 0 || used_bits + bits > 8) {
-            return nullptr;
-        }
-
-        mergeShuftiMask(&ns->lo, lo, used_bits);
-        mergeShuftiMask(&ns->hi, hi, used_bits);
-        for (u32 i = used_bits; i < used_bits + bits; i++) {
-            shuf_bit_to_impl.push_back(&cr);
-        }
-        used_bits += bits;
-    }
-
-    flipShuftiMask(&ns->lo); /* we are shift-or around here */
-    flipShuftiMask(&ns->hi);
-    ns->header.mask_bit_count = used_bits;
-
-    /* populate the enable masks */
-    u8 *table = (u8 *)((char *)ns + sizeof(*ns));
-    u32 b = 0;
-    for (const CharReach *cr : shuf_bit_to_impl) {
-        const set<u32> &rep_set = impl_classes.find(*cr)->second;
-        for (u32 report : rep_set) {
-            set_bit(&table[report], b);
-        }
-        if (rep_set.size() == 1) {
-            set_bit(&ns->unshared_mask, b);
-        }
-        b++;
-    }
-
-    /* populate the report id masks */
-    sidecar_id_offset temp_id_list[8];
-    populateMaskInfo<SIDECAR_S>(impl_classes, id_count, ns, temp_id_list);
-
-    u32 i = 0, j = 0;
-    auto iit = impl_classes.begin();
-    while (i < shuf_bit_to_impl.size()) {
-        assert(iit != impl_classes.end());
-        if (shuf_bit_to_impl[i] == &iit->first) {
-            ns->id_list[i] = temp_id_list[j];
-            i++;
-        } else {
-            j++;
-            ++iit;
-        }
-    }
-
-    return s;
-}
-
-static
-aligned_unique_ptr<sidecar>
-constructWithHint(int hint, const vector<CharReach> &classes,
-                  const map<CharReach, set<u32>> &impl_classes) {
-    switch (hint) {
-    case SIDECAR_8:
-        return construct<SIDECAR_8>(classes, impl_classes, true);
-    case SIDECAR_32:
-        return construct<SIDECAR_32>(classes, impl_classes, true);
-    case SIDECAR_64:
-        return construct<SIDECAR_64>(classes, impl_classes, true);
-    case SIDECAR_128:
-        return construct<SIDECAR_128>(classes, impl_classes, true);
-    case SIDECAR_256:
-        return construct<SIDECAR_256>(classes, impl_classes, true);
-    case SIDECAR_N:
-        return construct<SIDECAR_N>(classes, impl_classes, true);
-    case SIDECAR_S:
-        return construct<SIDECAR_S>(classes, impl_classes, true);
-    default:
-        DEBUG_PRINTF("derp\n");
-        assert(0);
-        return nullptr;
-    }
-}
-
-aligned_unique_ptr<sidecar> sidecarCompile(const vector<CharReach> &classes,
-                                           int hint) {
-    array<set<u32>, N_CHARS> by_char;
-
-    for (u32 i = 0; i < classes.size(); i++) {
-        const CharReach &cr = classes[i];
-        for (size_t j = cr.find_first(); j != cr.npos; j = cr.find_next(j)) {
-            by_char[j].insert(i);
-        }
-    }
-
-    map<CharReach, set<u32>> impl_classes;
-
-    bool changed;
-    do {
-        changed = false;
-        u32 smallest = N_CHARS;
-        for (u32 i = 0; i < N_CHARS; i++) {
-            if (by_char[i].empty()) {
-                continue;
-            }
-
-            if (by_char[i].size() == 1) {
-                prune(by_char, i, &impl_classes);
-                changed = true;
-            } else if (smallest == N_CHARS ||
-                       by_char[i].size() < by_char[smallest].size()) {
-                smallest = i;
-            }
-        }
-
-        if (!changed && smallest != N_CHARS) {
-            prune(by_char, smallest, &impl_classes);
-            changed = true;
-        }
-    } while (changed);
-
-    DEBUG_PRINTF("matching %zu classes; %zu impl classes\n", classes.size(),
-                 impl_classes.size());
-    assert(impl_classes.size() <= N_CHARS);
-
-    if (hint != SIDECAR_NO_HINT) {
-        return constructWithHint(hint, classes, impl_classes);
-    }
-
-    aligned_unique_ptr<sidecar> (*facts[])(const vector<CharReach> &,
-                        const map<CharReach, set<u32> > &, bool) = {
-        construct<SIDECAR_N>,
-        // construct<SIDECAR_S>, TODO: first offset stuff for S
-        construct<SIDECAR_8>,
-        construct<SIDECAR_32>,
-        construct<SIDECAR_64>,
-        construct<SIDECAR_128>,
-        construct<SIDECAR_256>
-    };
-
-    for (u32 i = 0; i < ARRAY_LENGTH(facts); i++) {
-        auto sc = facts[i](classes, impl_classes, false);
-        if (sc) {
-            return sc;
-        }
-    }
-
-    for (u32 i = 0; i < ARRAY_LENGTH(facts); i++) {
-        auto sc = facts[i](classes, impl_classes, true);
-        if (sc) {
-            return sc;
-        }
-    }
-
-    return nullptr;
-}
-
-u32 sidecarSize(const sidecar *ns) {
-    return ns->size;
-}
-
-u32 sidecarEnabledSize(const sidecar *n) {
-    switch (n->type) {
-    case SIDECAR_8:
-        return sizeof(struct sidecar_enabled_8);
-    case SIDECAR_32:
-        return sizeof(struct sidecar_enabled_32);
-    case SIDECAR_64:
-        return sizeof(struct sidecar_enabled_64);
-    case SIDECAR_128:
-        return sizeof(struct sidecar_enabled_128);
-    case SIDECAR_256:
-        return sizeof(struct sidecar_enabled_256);
-    case SIDECAR_N:
-        return sizeof(struct sidecar_enabled_N);
-    case SIDECAR_S:
-        return sizeof(struct sidecar_enabled_S);
-    default:
-        assert(0);
-    }
-    return 0;
-}
-
-template<u8 s_type>
-static
-void sidecarEnabledAdd_int(const sidecar *nn, struct sidecar_enabled *enabled,
-                           u32 id) {
-    typedef typename sidecar_traits<s_type>::enabled_type e_type;
-    typedef typename sidecar_traits<s_type>::impl_type n_type;
-    e_type *e = (e_type *)enabled;
-    const n_type *n = (const n_type *)nn;
-
-    DEBUG_PRINTF("enabling %u\n", id);
-    typedef typename sidecar_traits<s_type>::base_type base;
-    const base *masks = (const base *)sidecar_ids_to_mask_const(n);
-    or_into_mask(&e->bits, masks[id]);
-}
-
-template<>
-void sidecarEnabledAdd_int<SIDECAR_S>(const sidecar *nn,
-                                      sidecar_enabled *enabled, u32 id) {
-    const sidecar_S *n = (const sidecar_S *)nn;
-    sidecar_enabled_S *e = (sidecar_enabled_S *)enabled;
-    const u8 *masks = (const u8 *)sidecar_ids_to_mask_const(n);
-    e->bits |= masks[id];
-}
-
-template<>
-void sidecarEnabledAdd_int<SIDECAR_N>(UNUSED const sidecar *n,
-                                      struct sidecar_enabled *enabled,
-                                      UNUSED u32 id) {
-    sidecar_enabled_N *e = (sidecar_enabled_N *)enabled;
-    /* assuming we are not being called by a complete idiot, there is only one
-     * thing we could be asked to do here */
-    e->bits = 1;
-}
-
-void sidecarEnabledAdd(const sidecar *n, struct sidecar_enabled *enabled,
-                       u32 id) {
-    DEBUG_PRINTF("enabling %hhu:%u\n", n->type, id);
-    switch (n->type) {
-    case SIDECAR_8:
-        sidecarEnabledAdd_int<SIDECAR_8>(n, enabled, id);
-        break;
-    case SIDECAR_32:
-        sidecarEnabledAdd_int<SIDECAR_32>(n, enabled, id);
-        break;
-    case SIDECAR_64:
-        sidecarEnabledAdd_int<SIDECAR_64>(n, enabled, id);
-        break;
-    case SIDECAR_128:
-        sidecarEnabledAdd_int<SIDECAR_128>(n, enabled, id);
-        break;
-    case SIDECAR_256:
-        sidecarEnabledAdd_int<SIDECAR_256>(n, enabled, id);
-        break;
-    case SIDECAR_N:
-        sidecarEnabledAdd_int<SIDECAR_N>(n, enabled, id);
-        break;
-    case SIDECAR_S:
-        sidecarEnabledAdd_int<SIDECAR_S>(n, enabled, id);
-        break;
-    default:
-        assert(0);
-    }
-}
-
-} // namespace ue2
diff --git a/src/sidecar/sidecar_generic.h b/src/sidecar/sidecar_generic.h
deleted file mode 100644
index f5788fec..00000000
--- a/src/sidecar/sidecar_generic.h
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * Copyright (c) 2015, Intel Corporation
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of Intel Corporation nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/* in param TAG, STATE_T */
-
-#include "util/join.h"
-
-#if TAG == 8
-#define ISTATE_T u32
-#else
-#define ISTATE_T STATE_T
-#endif
-
-#define EXEC_FN JOIN(sidecarExec_, TAG)
-#define EXEC_I_FN JOIN(sidecarExec_i_, TAG)
-#define ENABLED_INIT_FN JOIN(sidecarEnabledInit_, TAG)
-#define ENABLED_UNION_FN JOIN(sidecarEnabledUnion_, TAG)
-#define ENABLED_STRUCT JOIN(struct sidecar_enabled_, TAG)
-#define PLAY_CB_FB JOIN(sidecarPlayCallbacks_, STATE_T)
-#define SIDECAR_STRUCT JOIN(struct sidecar_, TAG)
-#define MR_STRUCT JOIN(struct sidecar_mr_, TAG)
-#define load_state JOIN(load_, STATE_T)
-#define store_state JOIN(store_, STATE_T)
-#define and_state JOIN(and_, STATE_T)
-#define iand_state JOIN(and_, ISTATE_T)
-#define andnot_state JOIN(andnot_, STATE_T)
-#define or_state JOIN(or_, STATE_T)
-#define is_zero JOIN(isZero_, STATE_T)
-#define iis_zero JOIN(isZero_, ISTATE_T)
-#define is_not_zero JOIN(isNonZero_, ISTATE_T)
-#define not_eq JOIN(noteq_, STATE_T)
-#define inot_eq JOIN(noteq_, ISTATE_T)
-#define find_and_clear_lsb JOIN(findAndClearLSB_, TAG)
-#define zero_state JOIN(zero_, ISTATE_T)
-
-#if TAG <= 64
-#define TDEBUG_PRINTF(...) DEBUG_PRINTF(__VA_ARGS__)
-#define ATDEBUG_PRINTF(...) ADEBUG_PRINTF(__VA_ARGS__)
-#else
-#define TDEBUG_PRINTF(...) do { } while(0)
-#define ATDEBUG_PRINTF(...) do { } while(0)
-#endif
-
-MR_STRUCT {
-    const u8 *loc;
-    STATE_T mask;
-};
-
-static really_inline
-void PLAY_CB_FB(const SIDECAR_STRUCT *n, const u8 *b, const MR_STRUCT *matches,
-                u32 match_len, ENABLED_STRUCT *enabled, u64a base_offset,
-                SidecarCallback cb, void *context) {
-    const STATE_T *id_mask_map = sidecar_ids_to_mask_const(n);
-    const struct sidecar_id_offset *id_map = n->id_list;
-
-    STATE_T e_local = load_state(&enabled->bits);
-
-    DEBUG_PRINTF("playing %u matches\n", match_len);
-    TDEBUG_PRINTF("enabled %08llu\n", (u64a)enabled->bits);
-
-    for (u32 i = 0; i < match_len; i++) {
-        u64a offset = matches[i].loc - b + base_offset;
-        DEBUG_PRINTF("match at %llu\n", offset);
-
-        STATE_T local_m = andnot_state(load_state(&matches[i].mask), e_local);
-
-        e_local = and_state(matches[i].mask, e_local);
-
-        TDEBUG_PRINTF("%08llu=~%08llu^%08llu\n", (u64a)local_m,
-                      (u64a)matches[i].mask, (u64a)e_local);
-
-        while (is_not_zero(local_m)) {
-            u32 bit = find_and_clear_lsb(&local_m);
-            DEBUG_PRINTF("bit %u at %llu\n", bit, offset);
-            const u32 *id_base = (const u32 *)
-                ((const char *)n + id_map[bit].first_offset);
-            assert(ISALIGNED_N(id_base, 4));
-            u32 count = id_map[bit].count;
-            for (u32 j = 0; j < count; ++j) {
-                cb(offset, id_base[j], context);
-                STATE_T u_local = and_state(id_mask_map[id_base[j]],
-                                            load_state(&n->unshared_mask));
-                DEBUG_PRINTF("squashing unshared???\n");
-                e_local = andnot_state(u_local, e_local);
-                local_m = andnot_state(u_local, local_m);
-            }
-        }
-    }
-
-    TDEBUG_PRINTF("enabled %08llu\n", (u64a)e_local);
-    store_state(&enabled->bits, e_local);
-}
-
-/* returns count of match locations */
-static really_inline
-MR_STRUCT *EXEC_I_FN(const SIDECAR_STRUCT *n, const u8 *b, const u8 *b_end,
-              STATE_T state_in, MR_STRUCT *matches) {
-    DEBUG_PRINTF("running over %zu\n", b_end - b);
-    const STATE_T *table = (const STATE_T *)&n->reach;
-    ISTATE_T s = state_in;
-
-    b_end--; /* last byte is unrolled at end of function */
-    for (; b < b_end; b++) {
-        u8 c = *b;
-        ISTATE_T r = table[c];
-        ISTATE_T s1 = iand_state(s, r);
-        if (inot_eq(s1, s)) {
-            TDEBUG_PRINTF("recording match %08llu\n", (u64a)s1);
-            matches->loc = b;
-            store_state(&matches->mask, s1);
-            matches++;
-            if (DO_DEAD_CHECK && iis_zero(s1)) {
-                goto done;
-            }
-        }
-        s = s1;
-    }
-
-    /* do final byte by itself; gain blessing from the gcc gods */
-    u8 c = *b;
-    ISTATE_T r = table[c];
-    ISTATE_T s1 = iand_state(s, r);
-    if (inot_eq(s1, s)) {
-        TDEBUG_PRINTF("recording match %08llu\n", (u64a)s1);
-        matches->loc = b;
-        matches->mask = s1;
-        matches++;
-    }
-
-done:
-    return matches;
-}
-
-static never_inline
-void EXEC_FN(const SIDECAR_STRUCT *n, const u8 *b, size_t len,
-             ENABLED_STRUCT *enabled, struct sidecar_scratch *scratch,
-             u64a base_offset, SidecarCallback cb, void *context) {
-    STATE_T e_local = load_state(&enabled->bits);
-    if (is_zero(e_local)) {
-        return;
-    }
-
-    MR_STRUCT *matches = (MR_STRUCT *)scratch;
-    DEBUG_PRINTF("running sidecar over %zu len\n", len);
-    DEBUG_PRINTF("enabled %p scratch %p\n", enabled, scratch);
-    TDEBUG_PRINTF("enabled %08llu\n", (u64a)enabled->bits);
-    MR_STRUCT *matches_out = EXEC_I_FN(n, b, b + len, e_local, matches);
-    TDEBUG_PRINTF("enabled %08llu\n", (u64a)enabled->bits);
-    if (matches_out - matches) {
-        PLAY_CB_FB(n, b, matches, matches_out - matches, enabled, base_offset,
-                   cb, context);
-    }
-
-    TDEBUG_PRINTF("enabled %08llu\n", (u64a)enabled->bits);
-}
-
-static really_inline
-void ENABLED_INIT_FN(struct sidecar_enabled *enabled) {
-    ENABLED_STRUCT *e = (void *)enabled;
-    store_state(&e->bits, zero_state);
-}
-
-static really_inline
-void ENABLED_UNION_FN(struct sidecar_enabled *dest,
-                           const struct sidecar_enabled *src) {
-    ENABLED_STRUCT *d = (void *)dest;
-    const ENABLED_STRUCT *s = (const void *)src;
-    store_state(&d->bits, or_state(load_state(&d->bits), load_state(&s->bits)));
-}
-
-
-#undef ENABLED_STRUCT
-#undef ENABLED_INIT_FN
-#undef ENABLED_UNION_FN
-#undef EXEC_FN
-#undef EXEC_I_FN
-#undef load_state
-#undef MR_STRUCT
-#undef PLAY_CB_FB
-#undef SIDECAR_STRUCT
-#undef store_state
-#undef and_state
-#undef iand_state
-#undef andnot_state
-#undef not_eq
-#undef inot_eq
-#undef or_state
-#undef is_zero
-#undef is_not_zero
-#undef zero_state
-
-#undef TDEBUG_PRINTF
-#undef ATDEBUG_PRINTF
-
-#undef ISTATE_T
-
-#undef TAG
-#undef STATE_T
diff --git a/src/sidecar/sidecar_internal.h b/src/sidecar/sidecar_internal.h
deleted file mode 100644
index d1725355..00000000
--- a/src/sidecar/sidecar_internal.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (c) 2015, Intel Corporation
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of Intel Corporation nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SIDECAR_INTERNAL_H
-#define SIDECAR_INTERNAL_H
-
-#include "ue2common.h"
-
-#define SIDECAR_8   0
-#define SIDECAR_32  1
-#define SIDECAR_64  2
-#define SIDECAR_128 3
-#define SIDECAR_256 4
-#define SIDECAR_N   5
-#define SIDECAR_S   6
-
-struct sidecar_id_offset {
-    u32 first_offset; /* from base of sidecar */
-    u32 count;
-};
-
-struct sidecar {
-    u8 type;
-    u32 size;
-    u32 id_count;
-    u32 mask_bit_count;
-}; /* .. followed in memory by reach table */
-
-#define SIDECAR_SPEC(bit_count, base_type)      \
-struct sidecar_##bit_count {                    \
-    struct sidecar header;                      \
-    base_type reach[N_CHARS];                    \
-    struct sidecar_id_offset id_list[bit_count];\
-    base_type unshared_mask;                    \
-};
-
-struct sidecar_N {
-    struct sidecar header;
-    char c;
-    char nocase;
-    u32 report_count;
-    u32 reports[];
-};
-
-struct sidecar_S {
-    struct sidecar header;
-    m128 hi;
-    m128 lo;
-    struct sidecar_id_offset id_list[8];
-    u8 unshared_mask;
-};
-
-SIDECAR_SPEC(8,   u8)
-SIDECAR_SPEC(32,  u32)
-SIDECAR_SPEC(64,  u64a)
-SIDECAR_SPEC(128, m128)
-SIDECAR_SPEC(256, m256)
-
-struct sidecar_enabled {
-    u8 null;
-};
-
-struct sidecar_enabled_8 {
-    u8 bits;
-};
-
-struct sidecar_enabled_32 {
-    u32 bits;
-};
-
-struct sidecar_enabled_64 {
-    u64a bits;
-};
-
-struct sidecar_enabled_128 {
-    m128 bits;
-};
-
-struct sidecar_enabled_256 {
-    m256 bits;
-};
-
-struct sidecar_enabled_N {
-    u8 bits;
-};
-
-struct sidecar_enabled_S {
-    u8 bits;
-};
-
-union sidecar_enabled_any {
-    struct sidecar_enabled     arb;
-    struct sidecar_enabled_8   e8;
-    struct sidecar_enabled_32  e32;
-    struct sidecar_enabled_64  e64;
-    struct sidecar_enabled_128 e128;
-    struct sidecar_enabled_256 e256;
-    struct sidecar_enabled_N eN;
-    struct sidecar_enabled_S eS;
-};
-
-/* ASCII ART TIME
- *
- * non-noodle sidecars
- *
- * ---------------------
- *    [  struct sidecar  ] ROUNDUP_16(sizeof(sidecar))
- *    ---------------------                                |
- *    [                   ]                                | Shufti: masks here
- *    [    reach table    ] sizeof(N) * N_CHARS            |
- *    [                   ]                                |
- *    ---------------------
- *    [ bit->id list head ] N * sizeof(sidecar_id_offset)
- *    ---------------------
- * --------------------- sizeof(sidecar_N)
- * [                   ]
- * [     id->masks     ] count(id) * sizeof(N)
- * [                   ]
- * ---------------------
- * [                   ]
- * [      id lists     ] complicated * sizeof(report)
- * [                   ]
- * ---------------------
- */
-
-#define sidecar_ids_to_mask_const(side_struct)                          \
-    ((const void *)((const char *)side_struct + sizeof(*side_struct)))
-
-
-
-#endif
diff --git a/src/sidecar/sidecar_shufti.c b/src/sidecar/sidecar_shufti.c
deleted file mode 100644
index 51969ddc..00000000
--- a/src/sidecar/sidecar_shufti.c
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright (c) 2015, Intel Corporation
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of Intel Corporation nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "sidecar_shufti.h"
-#include "sidecar_internal.h"
-#include "ue2common.h"
-#include "util/simd_utils.h"
-#include "util/simd_utils_ssse3.h"
-
-#define GET_LO_4(chars) and128(chars, low4bits)
-#define GET_HI_4(chars) rshift2x64(andnot128(low4bits, chars), 4)
-
-#ifdef DEBUG
-#include <ctype.h>
-UNUSED static void dumpMsk(m128 msk) {
-    u8 *maskAsU8 = (u8 *)&msk;
-    for (int i = 0; i < 16; i++) {
-        printf("%02hhx ", maskAsU8[i]);
-    }
-}
-
-UNUSED static void dumpMskAsChars(m128 msk) {
-    u8 *maskAsU8 = (u8 *)&msk;
-    for (int i = 0; i < 16; i++) {
-        u8 c = maskAsU8[i];
-        if (isprint(c))
-            printf("%c",c);
-        else
-            printf(".");
-    }
-}
-#endif
-
-static really_inline
-u8 squash(m128 t) {
-    m128 u = byteShiftRight128(t, 8);
-    t = and128(t, u);
-    m128 v = byteShiftRight128(t, 4);
-    t = and128(t, v);
-    u32 gpr = movd(t);
-    gpr &= gpr >> 16;
-    gpr &= gpr >> 8;
-    DEBUG_PRINTF("   gpr: %02x\n", (u8)gpr);
-    return (u8)gpr;
-}
-
-
-static really_inline
-m128 mainLoop(m128 mask_lo, m128 mask_hi, m128 chars, const m128 low4bits) {
-    m128 c_lo  = pshufb(mask_lo, GET_LO_4(chars));
-    m128 c_hi  = pshufb(mask_hi, GET_HI_4(chars));
-    m128 t     = or128(c_lo, c_hi);
-
-#ifdef DEBUG
-    DEBUG_PRINTF(" chars: "); dumpMskAsChars(chars); printf("\n");
-    DEBUG_PRINTF("  char: "); dumpMsk(chars);        printf("\n");
-    DEBUG_PRINTF("  c_lo: "); dumpMsk(c_lo);         printf("\n");
-    DEBUG_PRINTF("  c_hi: "); dumpMsk(c_hi);         printf("\n");
-    DEBUG_PRINTF("     t: "); dumpMsk(t);            printf("\n");
-#endif
-
-    return t;
-}
-
-u8 sidecarExec_S_int(const struct sidecar_S *n, const u8 *b,
-                     size_t len, u8 state) {
-    const m128 low4bits = _mm_set1_epi8(0xf);
-    const u8 *b_end = b + len;
-    m128 mask_lo = n->lo;
-    m128 mask_hi = n->hi;
-
-    // Preconditioning: most of the time our buffer won't be aligned
-    DEBUG_PRINTF("warmup %02hhx\n", state);
-    m128 chars = loadu128(b);
-    m128 t =  _mm_set1_epi8(state);
-    t = and128(t, mainLoop(mask_lo, mask_hi, chars, low4bits));
-    b = ROUNDUP_PTR(b + 1, 16);
-
-    // Unrolling was here, but it wasn't doing anything but taking up space.
-    // Reroll FTW.
-
-    DEBUG_PRINTF("main %02hhx\n", state);
-    const u8 *last_block = b_end - 16;
-    while (b < last_block) {
-        m128 lchars = load128(b);
-        m128 rv = mainLoop(mask_lo, mask_hi, lchars, low4bits);
-        t = and128(t, rv);
-        b += 16;
-        if (!squash(t)) {
-            return 0;
-        }
-    }
-
-    DEBUG_PRINTF("cool down %02hhx\n", state);
-    assert(b <= b_end && b >= b_end - 16);
-    // do an unaligned load the end to accurate picture to the end
-    chars = loadu128(b_end - 16);
-    m128 rv = mainLoop(mask_lo, mask_hi, chars, low4bits);
-    t = and128(t, rv);
-
-    return squash(t);
-}
diff --git a/src/smallwrite/smallwrite_build.cpp b/src/smallwrite/smallwrite_build.cpp
index 097e0432..792a3d5b 100644
--- a/src/smallwrite/smallwrite_build.cpp
+++ b/src/smallwrite/smallwrite_build.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -303,35 +303,38 @@ bool is_slow(const raw_dfa &rdfa, const set<dstate_id_t> &accel,
 
 static
 aligned_unique_ptr<NFA> prepEngine(raw_dfa &rdfa, u32 roseQuality,
-                                   const CompileContext &cc, u32 *start_offset,
+                                   const CompileContext &cc,
+                                   const ReportManager &rm, u32 *start_offset,
                                    u32 *small_region) {
     *start_offset = remove_leading_dots(rdfa);
 
     // Unleash the McClellan!
     set<dstate_id_t> accel_states;
 
-    auto nfa = mcclellanCompile(rdfa, cc, &accel_states);
+    auto nfa = mcclellanCompile(rdfa, cc, rm, &accel_states);
     if (!nfa) {
         DEBUG_PRINTF("mcclellan compile failed for smallwrite NFA\n");
         return nullptr;
     }
 
     if (is_slow(rdfa, accel_states, roseQuality)) {
+        DEBUG_PRINTF("is slow\n");
         *small_region = cc.grey.smallWriteLargestBufferBad;
         if (*small_region <= *start_offset) {
             return nullptr;
         }
-        prune_overlong(rdfa, *small_region - *start_offset);
-        if (rdfa.start_anchored == DEAD_STATE) {
-            DEBUG_PRINTF("all patterns pruned out\n");
-            return nullptr;
-        }
+        if (prune_overlong(rdfa, *small_region - *start_offset)) {
+            if (rdfa.start_anchored == DEAD_STATE) {
+                DEBUG_PRINTF("all patterns pruned out\n");
+                return nullptr;
+            }
 
-        nfa = mcclellanCompile(rdfa, cc, &accel_states);
-        if (!nfa) {
-            DEBUG_PRINTF("mcclellan compile failed for smallwrite NFA\n");
-            assert(0); /* we were able to build orig dfa but not the trimmed? */
-            return nullptr;
+            nfa = mcclellanCompile(rdfa, cc, rm, &accel_states);
+            if (!nfa) {
+                DEBUG_PRINTF("mcclellan compile failed for smallwrite NFA\n");
+                assert(0); /* able to build orig dfa but not the trimmed? */
+                return nullptr;
+            }
         }
     } else {
         *small_region = cc.grey.smallWriteLargestBuffer;
@@ -376,7 +379,8 @@ SmallWriteBuildImpl::build(u32 roseQuality) {
 
     u32 start_offset;
     u32 small_region;
-    auto nfa = prepEngine(*rdfa, roseQuality, cc, &start_offset, &small_region);
+    auto nfa =
+        prepEngine(*rdfa, roseQuality, cc, rm, &start_offset, &small_region);
     if (!nfa) {
         DEBUG_PRINTF("some smallwrite outfix could not be prepped\n");
         /* just skip the smallwrite optimization */
diff --git a/src/som/som_operation.h b/src/som/som_operation.h
new file mode 100644
index 00000000..d85ad226
--- /dev/null
+++ b/src/som/som_operation.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * \file
+ * \brief SOM runtime: data structures.
+ *
+ * Data structures used for SOM operations.
+ */
+
+#ifndef SOM_OPERATION_H
+#define SOM_OPERATION_H
+
+#include "ue2common.h"
+
+#define SOM_EXTERNAL_CALLBACK_REL                     1
+#define SOM_INTERNAL_LOC_SET                          2
+#define SOM_INTERNAL_LOC_SET_IF_UNSET                 3
+#define SOM_INTERNAL_LOC_SET_IF_WRITABLE              4
+#define SOM_INTERNAL_LOC_SET_REV_NFA                  5
+#define SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET         6
+#define SOM_INTERNAL_LOC_SET_REV_NFA_IF_WRITABLE      7
+#define SOM_INTERNAL_LOC_COPY                         8
+#define SOM_INTERNAL_LOC_COPY_IF_WRITABLE             9
+#define SOM_INTERNAL_LOC_MAKE_WRITABLE               10
+#define SOM_EXTERNAL_CALLBACK_STORED                 11
+#define SOM_EXTERNAL_CALLBACK_ABS                    12
+#define SOM_EXTERNAL_CALLBACK_REV_NFA                13
+#define SOM_INTERNAL_LOC_SET_FROM                    14
+#define SOM_INTERNAL_LOC_SET_FROM_IF_WRITABLE        15
+
+struct som_operation {
+    /** \brief Report type, from the definitions above. */
+    u8 type;
+
+    /* \brief SOM loc to modify. */
+    u32 onmatch;
+
+    union {
+        /** \brief SOM distance value, use varies according to type.
+         *
+         *  - for SOM_EXTERNAL_CALLBACK_REL, from-offset is this many bytes
+         *    before the to-offset.
+         *  - for SOM_EXTERNAL_CALLBACK_ABS, set from-offset to this value.
+         *  - for SOM_INTERNAL_LOC_COPY*, som location read_from.
+         */
+        u64a somDistance;
+
+        /** \brief Index of the reverse nfa.
+         *
+         * Used by SOM_EXTERNAL_CALLBACK_REV_NFA and
+         * SOM_INTERNAL_LOC_SET_REV_NFA*.
+         */
+        u64a revNfaIndex;
+    } aux;
+};
+
+#endif // SOM_OPERATION_H
+
diff --git a/src/som/som_runtime.c b/src/som/som_runtime.c
index 23f2b282..9d0a1390 100644
--- a/src/som/som_runtime.c
+++ b/src/som/som_runtime.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -39,6 +39,7 @@
  */
 
 #include "hs_internal.h"
+#include "som_operation.h"
 #include "som_runtime.h"
 #include "scratch.h"
 #include "ue2common.h"
@@ -47,11 +48,10 @@
 #include "nfa/nfa_internal.h"
 #include "util/fatbit.h"
 #include "util/multibit.h"
-#include "util/internal_report.h"
 
 static really_inline
 void setSomLoc(struct fatbit *som_set_now, u64a *som_store, u32 som_store_count,
-               const struct internal_report *ri, u64a to_offset) {
+               const struct som_operation *ri, u64a to_offset) {
     /* validity handled by callers */
     assert(to_offset >= ri->aux.somDistance);
     u64a start_offset = to_offset - ri->aux.somDistance;
@@ -112,7 +112,7 @@ const struct NFA *getSomRevNFA(const struct RoseEngine *t, u32 i) {
 }
 
 static
-void runRevNfa(struct hs_scratch *scratch, const struct internal_report *ri,
+void runRevNfa(struct hs_scratch *scratch, const struct som_operation *ri,
                const u64a to_offset, u64a *from_offset) {
     struct core_info *ci = &scratch->core_info;
 
@@ -151,7 +151,7 @@ void runRevNfa(struct hs_scratch *scratch, const struct internal_report *ri,
     *from_offset = to_offset;
 
     nfaBlockExecReverse(nfa, to_offset, buf, buf_bytes, hbuf, history_bytes,
-                        scratch, somRevCallback, from_offset);
+                        somRevCallback, from_offset);
 
     assert(*from_offset <= to_offset);
 }
@@ -159,7 +159,7 @@ void runRevNfa(struct hs_scratch *scratch, const struct internal_report *ri,
 static really_inline
 void setSomLocRevNfa(struct hs_scratch *scratch, struct fatbit *som_set_now,
                      u64a *som_store, u32 som_store_count,
-                     const struct internal_report *ri, u64a to_offset) {
+                     const struct som_operation *ri, u64a to_offset) {
     /* validity handled by callers */
     u64a from_offset = 0;
     runRevNfa(scratch, ri, to_offset, &from_offset);
@@ -178,7 +178,7 @@ void setSomLocRevNfa(struct hs_scratch *scratch, struct fatbit *som_set_now,
 }
 
 void handleSomInternal(struct hs_scratch *scratch,
-                       const struct internal_report *ri, const u64a to_offset) {
+                       const struct som_operation *ri, const u64a to_offset) {
     assert(scratch);
     assert(ri);
     DEBUG_PRINTF("-->som action required at %llu\n", to_offset);
@@ -209,21 +209,21 @@ void handleSomInternal(struct hs_scratch *scratch,
     }
 
     switch (ri->type) {
-    case INTERNAL_SOM_LOC_SET:
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_SET\n");
+    case SOM_INTERNAL_LOC_SET:
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_SET\n");
         mmbit_set(som_store_valid, som_store_count, ri->onmatch);
         setSomLoc(som_set_now, som_store, som_store_count, ri, to_offset);
         return;
-    case INTERNAL_SOM_LOC_SET_IF_UNSET:
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_SET_IF_UNSET\n");
+    case SOM_INTERNAL_LOC_SET_IF_UNSET:
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_IF_UNSET\n");
         if (ok_and_mark_if_unset(som_store_valid, som_set_now, som_store_count,
                                  ri->onmatch)) {
             setSomLoc(som_set_now, som_store, som_store_count, ri, to_offset);
         }
         return;
-    case INTERNAL_SOM_LOC_SET_IF_WRITABLE: {
+    case SOM_INTERNAL_LOC_SET_IF_WRITABLE: {
         u32 slot = ri->onmatch;
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_SET_IF_WRITABLE\n");
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_IF_WRITABLE\n");
         if (ok_and_mark_if_write(som_store_valid, som_set_now,
                                  som_store_writable, som_store_count, slot)) {
             setSomLoc(som_set_now, som_store, som_store_count, ri, to_offset);
@@ -245,23 +245,23 @@ void handleSomInternal(struct hs_scratch *scratch,
         }
         return;
     }
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA:
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_SET_SOM_REV_NFA\n");
+    case SOM_INTERNAL_LOC_SET_REV_NFA:
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_REV_NFA\n");
         mmbit_set(som_store_valid, som_store_count, ri->onmatch);
         setSomLocRevNfa(scratch, som_set_now, som_store, som_store_count, ri,
                         to_offset);
         return;
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET:
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET\n");
+    case SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET:
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET\n");
         if (ok_and_mark_if_unset(som_store_valid, som_set_now, som_store_count,
                                  ri->onmatch)) {
             setSomLocRevNfa(scratch, som_set_now, som_store, som_store_count,
                             ri, to_offset);
         }
         return;
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE: {
+    case SOM_INTERNAL_LOC_SET_REV_NFA_IF_WRITABLE: {
         u32 slot = ri->onmatch;
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_SET_IF_WRITABLE\n");
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_IF_WRITABLE\n");
         if (ok_and_mark_if_write(som_store_valid, som_set_now,
                                  som_store_writable, som_store_count, slot)) {
             setSomLocRevNfa(scratch, som_set_now, som_store, som_store_count,
@@ -285,10 +285,10 @@ void handleSomInternal(struct hs_scratch *scratch,
         }
         return;
     }
-    case INTERNAL_SOM_LOC_COPY: {
+    case SOM_INTERNAL_LOC_COPY: {
         u32 slot_in = ri->aux.somDistance;
         u32 slot_out = ri->onmatch;
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_COPY S[%u] = S[%u]\n", slot_out,
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_COPY S[%u] = S[%u]\n", slot_out,
                      slot_in);
         assert(mmbit_isset(som_store_valid, som_store_count, slot_in));
         mmbit_set(som_store_valid, som_store_count, slot_out);
@@ -297,10 +297,10 @@ void handleSomInternal(struct hs_scratch *scratch,
 
         return;
     }
-    case INTERNAL_SOM_LOC_COPY_IF_WRITABLE: {
+    case SOM_INTERNAL_LOC_COPY_IF_WRITABLE: {
         u32 slot_in = ri->aux.somDistance;
         u32 slot_out = ri->onmatch;
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_COPY_IF_WRITABLE S[%u] = S[%u]\n",
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_COPY_IF_WRITABLE S[%u] = S[%u]\n",
                      slot_out, slot_in);
         assert(mmbit_isset(som_store_valid, som_store_count, slot_in));
         if (ok_and_mark_if_write(som_store_valid, som_set_now,
@@ -322,9 +322,9 @@ void handleSomInternal(struct hs_scratch *scratch,
         }
         return;
     }
-    case INTERNAL_SOM_LOC_MAKE_WRITABLE: {
+    case SOM_INTERNAL_LOC_MAKE_WRITABLE: {
         u32 slot = ri->onmatch;
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_MAKE_WRITABLE\n");
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_MAKE_WRITABLE\n");
         /* if just written to the loc, ignore the racing escape */
         if (fatbit_isset(som_set_now, som_store_count, slot)) {
             DEBUG_PRINTF("just written\n");
@@ -347,14 +347,14 @@ void handleSomInternal(struct hs_scratch *scratch,
         break;
     }
 
-    // All valid internal_report types should be handled and returned above.
+    // All valid som_operation types should be handled and returned above.
     assert(0);
     return;
 }
 
 // Returns the SOM offset.
 u64a handleSomExternal(struct hs_scratch *scratch,
-                       const struct internal_report *ri,
+                       const struct som_operation *ri,
                        const u64a to_offset) {
     assert(scratch);
     assert(ri);
@@ -368,20 +368,20 @@ u64a handleSomExternal(struct hs_scratch *scratch,
     assert(rose->hasSom);
 
     switch (ri->type) {
-    case EXTERNAL_CALLBACK_SOM_REL:
-        DEBUG_PRINTF("EXTERNAL_CALLBACK_SOM_REL: som is %llu chars back\n",
+    case SOM_EXTERNAL_CALLBACK_REL:
+        DEBUG_PRINTF("SOM_EXTERNAL_CALLBACK_REL: som is %llu chars back\n",
                      ri->aux.somDistance);
         assert(to_offset >= ri->aux.somDistance);
         return to_offset - ri->aux.somDistance;
-    case EXTERNAL_CALLBACK_SOM_ABS:
-        DEBUG_PRINTF("EXTERNAL_CALLBACK_SOM_ABS: som is at %llu\n",
+    case SOM_EXTERNAL_CALLBACK_ABS:
+        DEBUG_PRINTF("SOM_EXTERNAL_CALLBACK_ABS: som is at %llu\n",
                      ri->aux.somDistance);
         assert(to_offset >= ri->aux.somDistance);
         return ri->aux.somDistance;
-    case EXTERNAL_CALLBACK_SOM_STORED: {
+    case SOM_EXTERNAL_CALLBACK_STORED: {
         const u64a *som_store = scratch->som_store;
         u32 slot = ri->aux.somDistance;
-        DEBUG_PRINTF("EXTERNAL_CALLBACK_SOM_STORED: <- som_store[%u]=%llu\n",
+        DEBUG_PRINTF("SOM_EXTERNAL_CALLBACK_STORED: <- som_store[%u]=%llu\n",
                      slot, som_store[slot]);
 
         UNUSED const u32 som_store_count = rose->somLocationCount;
@@ -391,8 +391,8 @@ u64a handleSomExternal(struct hs_scratch *scratch,
         assert(mmbit_isset(som_store_valid, som_store_count, slot));
         return som_store[slot];
     }
-    case EXTERNAL_CALLBACK_SOM_REV_NFA: {
-        DEBUG_PRINTF("EXTERNAL_CALLBACK_REV_NFA\n");
+    case SOM_EXTERNAL_CALLBACK_REV_NFA: {
+        DEBUG_PRINTF("SOM_EXTERNAL_CALLBACK_REV_NFA\n");
         u64a from_offset = 0;
         runRevNfa(scratch, ri, to_offset, &from_offset);
         return from_offset;
@@ -402,19 +402,19 @@ u64a handleSomExternal(struct hs_scratch *scratch,
         break;
     }
 
-    // All valid internal_report types should be handled and returned above.
+    // All valid som_operation types should be handled and returned above.
     assert(0);
     return 0;
 }
 
 void setSomFromSomAware(struct hs_scratch *scratch,
-                        const struct internal_report *ri, u64a from_offset,
+                        const struct som_operation *ri, u64a from_offset,
                         u64a to_offset) {
     assert(scratch);
     assert(ri);
     assert(to_offset);
-    assert(ri->type == INTERNAL_SOM_LOC_SET_FROM
-           || ri->type == INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE);
+    assert(ri->type == SOM_INTERNAL_LOC_SET_FROM
+           || ri->type == SOM_INTERNAL_LOC_SET_FROM_IF_WRITABLE);
 
     struct core_info *ci = &scratch->core_info;
     const struct RoseEngine *rose = ci->rose;
@@ -435,12 +435,12 @@ void setSomFromSomAware(struct hs_scratch *scratch,
         scratch->som_set_now_offset = to_offset;
     }
 
-    if (ri->type == INTERNAL_SOM_LOC_SET_FROM) {
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_SET_FROM\n");
+    if (ri->type == SOM_INTERNAL_LOC_SET_FROM) {
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_FROM\n");
         mmbit_set(som_store_valid, som_store_count, ri->onmatch);
         setSomLoc(som_set_now, som_store, som_store_count, ri, from_offset);
     } else {
-        DEBUG_PRINTF("INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE\n");
+        DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_FROM_IF_WRITABLE\n");
         if (ok_and_mark_if_write(som_store_valid, som_set_now,
                                  som_store_writable, som_store_count,
                                  ri->onmatch)) {
@@ -487,6 +487,7 @@ int clearSomLog(struct hs_scratch *scratch, u64a offset, struct fatbit *log,
         int halt = ci->userCallback(onmatch, from_offset, offset, flags,
                                     ci->userContext);
         if (halt) {
+            ci->status |= STATUS_TERMINATED;
             return 1;
         }
     }
diff --git a/src/som/som_runtime.h b/src/som/som_runtime.h
index a0baa763..30c7ace8 100644
--- a/src/som/som_runtime.h
+++ b/src/som/som_runtime.h
@@ -26,10 +26,10 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-/** \file
+/**
+ * \file
  * \brief SOM runtime code.
  *
- *
  * Runtime code for SOM handling called by the Rose callback adaptors.
  */
 
@@ -39,17 +39,17 @@
 #include "scratch.h"
 #include "ue2common.h"
 
-struct internal_report;
+struct som_operation;
 
 void handleSomInternal(struct hs_scratch *scratch,
-                       const struct internal_report *ri, const u64a to_offset);
+                       const struct som_operation *ri, const u64a to_offset);
 
 // Returns the from_offset.
 u64a handleSomExternal(struct hs_scratch *scratch,
-                       const struct internal_report *ri, const u64a to_offset);
+                       const struct som_operation *ri, const u64a to_offset);
 
 void setSomFromSomAware(struct hs_scratch *scratch,
-                        const struct internal_report *ri, u64a from_offset,
+                        const struct som_operation *ri, u64a from_offset,
                         u64a to_offset);
 
 int flushStoredSomMatches_i(struct hs_scratch *scratch, u64a offset);
diff --git a/src/ue2common.h b/src/ue2common.h
index b279f81a..2de60753 100644
--- a/src/ue2common.h
+++ b/src/ue2common.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -194,12 +194,20 @@ typedef u32 ReportID;
 #define unlikely(x)	(x)
 #endif
 
+#if !defined(RELEASE_BUILD) || defined(DEBUG)
+#ifdef _WIN32
+#define PATH_SEP '\\'
+#else
+#define PATH_SEP '/'
+#endif
+#endif
+
 #if defined(DEBUG) && !defined(DEBUG_PRINTF)
 #include <string.h>
 #include <stdio.h>
 #define DEBUG_PRINTF(format, ...) printf("%s:%s:%d:" format, \
-                                         strrchr(__FILE__, '/') + 1, __func__, \
-                                         __LINE__,  ## __VA_ARGS__)
+                                         strrchr(__FILE__, PATH_SEP) + 1, \
+                                         __func__, __LINE__,  ## __VA_ARGS__)
 #elif !defined(DEBUG_PRINTF)
 #define DEBUG_PRINTF(format, ...) do { } while(0)
 #endif
@@ -208,8 +216,8 @@ typedef u32 ReportID;
 #include <string.h>
 #include <stdio.h>
 #define ADEBUG_PRINTF(format, ...) printf("!%s:%s:%d:" format, \
-                                         strrchr(__FILE__, '/') + 1, __func__, \
-                                         __LINE__,  ## __VA_ARGS__)
+                                          strrchr(__FILE__, PATH_SEP) + 1, \
+                                          __func__, __LINE__,  ## __VA_ARGS__)
 #else
 #define ADEBUG_PRINTF(format, ...) do { } while(0)
 #endif
diff --git a/src/sidecar/sidecar_dump.h b/src/util/accel_scheme.h
similarity index 79%
rename from src/sidecar/sidecar_dump.h
rename to src/util/accel_scheme.h
index 8b6625f4..f524fe93 100644
--- a/src/sidecar/sidecar_dump.h
+++ b/src/util/accel_scheme.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,21 +26,26 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SIDECAR_DUMP_H
-#define SIDECAR_DUMP_H
+#ifndef ACCEL_SCHEME_H
+#define ACCEL_SCHEME_H
 
-#if defined(DUMP_SUPPORT)
+#include "util/charreach.h"
+#include "util/ue2_containers.h"
 
-#include <cstdio>
-
-struct sidecar;
+#include <utility>
 
 namespace ue2 {
 
-void sidecarDump(const sidecar *s, FILE *f);
+#define MAX_ACCEL_DEPTH 4
 
-} // namespace ue2
-
-#endif
+struct AccelScheme {
+    flat_set<std::pair<u8, u8> > double_byte;
+    CharReach cr = CharReach::dot();
+    CharReach double_cr;
+    u32 offset = MAX_ACCEL_DEPTH + 1;
+    u32 double_offset = 0;
+};
+
+}
 
 #endif
diff --git a/src/util/alloc.h b/src/util/alloc.h
index ab996a8d..191bc387 100644
--- a/src/util/alloc.h
+++ b/src/util/alloc.h
@@ -78,51 +78,42 @@ void aligned_free_internal(void *ptr);
 
 /** \brief Aligned allocator class for use with STL containers. Ensures that
  * your objects are aligned to N bytes. */
-template <typename T, std::size_t N> class AlignedAllocator {
+template <class T, std::size_t N>
+class AlignedAllocator {
 public:
-    typedef T value_type;
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef T *pointer;
-    typedef const T *const_pointer;
-    typedef T &reference;
-    typedef const T &const_reference;
+    using value_type = T;
 
-    template <typename U> struct rebind {
-        typedef AlignedAllocator<U, N> other;
+    AlignedAllocator() noexcept {}
+
+    template <class U, std::size_t N2>
+    AlignedAllocator(const AlignedAllocator<U, N2> &) noexcept {}
+
+    template <class U> struct rebind {
+        using other = AlignedAllocator<U, N>;
     };
 
-    pointer address(reference x) const { return &x; }
-    const_pointer address(const_reference x) const { return &x; }
-
-    size_type max_size() const {
-        return std::numeric_limits<size_type>::max() / sizeof(value_type);
+    T *allocate(std::size_t size) const {
+        size_t alloc_size = size * sizeof(T);
+        return static_cast<T *>(aligned_malloc_internal(alloc_size, N));
     }
 
-    pointer allocate(size_type size) const {
-        return static_cast<pointer>(
-            aligned_malloc_internal(size * sizeof(value_type), N));
-    }
-
-    void deallocate(pointer x, size_type) const { aligned_free_internal(x); }
-
-    void construct(pointer x, const value_type &val) const {
-        new (x) value_type(val);
-    }
-
-    void destroy(pointer p) const { p->~value_type(); }
-
-    bool operator==(const AlignedAllocator<T, N> &) const {
-        // All instances of AlignedAllocator can dealloc each others' memory.
-        return true;
-    }
-
-    bool operator!=(const AlignedAllocator<T, N> &) const {
-        // All instances of AlignedAllocator can dealloc each others' memory.
-        return false;
+    void deallocate(T *x, std::size_t) const noexcept {
+        aligned_free_internal(x);
     }
 };
 
+template <class T, class U, std::size_t N, std::size_t N2>
+bool operator==(const AlignedAllocator<T, N> &,
+                const AlignedAllocator<U, N2> &) {
+    return true;
+}
+
+template <class T, class U, std::size_t N, std::size_t N2>
+bool operator!=(const AlignedAllocator<T, N> &a,
+                const AlignedAllocator<U, N2> &b) {
+    return !(a == b);
+}
+
 } // namespace ue2
 
 #endif
diff --git a/src/util/bitfield.h b/src/util/bitfield.h
index 208c2ef5..a71c1f88 100644
--- a/src/util/bitfield.h
+++ b/src/util/bitfield.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -187,8 +187,15 @@ public:
     size_t count() const {
         static_assert(block_size == 64, "adjust popcount for block_type");
         size_t sum = 0;
-        for (const auto &e : bits) {
-            sum += popcount64(e);
+        size_t i = 0;
+        for (; i + 4 <= num_blocks; i += 4) {
+            sum += popcount64(bits[i]);
+            sum += popcount64(bits[i + 1]);
+            sum += popcount64(bits[i + 2]);
+            sum += popcount64(bits[i + 3]);
+        }
+        for (; i < num_blocks; i++) {
+            sum += popcount64(bits[i]);
         }
         assert(sum <= size());
         return sum;
@@ -298,49 +305,61 @@ public:
     }
 
     /// Bitwise OR.
-    bitfield operator|(const bitfield &a) const {
-        bitfield cr;
-        for (size_t i = 0; i < bits.size(); i++) {
-            cr.bits[i] = bits[i] | a.bits[i];
-        }
-        return cr;
+    bitfield operator|(bitfield a) const {
+        a |= *this;
+        return a;
     }
 
     /// Bitwise OR-equals.
     void operator|=(const bitfield &a) {
-        for (size_t i = 0; i < bits.size(); i++) {
+        size_t i = 0;
+        for (; i + 4 <= num_blocks; i += 4) {
+            bits[i]     |= a.bits[i];
+            bits[i + 1] |= a.bits[i + 1];
+            bits[i + 2] |= a.bits[i + 2];
+            bits[i + 3] |= a.bits[i + 3];
+        }
+        for (; i < num_blocks; i++) {
             bits[i] |= a.bits[i];
         }
     }
 
     /// Bitwise AND.
-    bitfield operator&(const bitfield &a) const {
-        bitfield cr;
-        for (size_t i = 0; i < bits.size(); i++) {
-            cr.bits[i] = bits[i] & a.bits[i];
-        }
-        return cr;
+    bitfield operator&(bitfield a) const {
+        a &= *this;
+        return a;
     }
 
     /// Bitwise AND-equals.
     void operator&=(const bitfield &a) {
-        for (size_t i = 0; i < bits.size(); i++) {
+        size_t i = 0;
+        for (; i + 4 <= num_blocks; i += 4) {
+            bits[i]     &= a.bits[i];
+            bits[i + 1] &= a.bits[i + 1];
+            bits[i + 2] &= a.bits[i + 2];
+            bits[i + 3] &= a.bits[i + 3];
+        }
+        for (; i < num_blocks; i++) {
             bits[i] &= a.bits[i];
         }
     }
 
     /// Bitwise XOR.
-    bitfield operator^(const bitfield &a) const {
-        bitfield cr;
-        for (size_t i = 0; i < bits.size(); i++) {
-            cr.bits[i] = bits[i] ^ a.bits[i];
-        }
-        return cr;
+    bitfield operator^(bitfield a) const {
+        a ^= *this;
+        return a;
     }
 
     /// Bitwise XOR-equals.
-    void operator^=(const bitfield &a) {
-        for (size_t i = 0; i < bits.size(); i++) {
+    void operator^=(bitfield a) {
+        size_t i = 0;
+        for (; i + 4 <= num_blocks; i += 4) {
+            bits[i]     ^= a.bits[i];
+            bits[i + 1] ^= a.bits[i + 1];
+            bits[i + 2] ^= a.bits[i + 2];
+            bits[i + 3] ^= a.bits[i + 3];
+        }
+        for (; i < num_blocks; i++) {
             bits[i] ^= a.bits[i];
         }
     }
diff --git a/src/util/bitutils.h b/src/util/bitutils.h
index 979a2c04..c863fba9 100644
--- a/src/util/bitutils.h
+++ b/src/util/bitutils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -86,10 +86,20 @@ u32 clz32(u32 x) {
 static really_inline
 u32 clz64(u64a x) {
     assert(x); // behaviour not defined for x == 0
-#if defined(_WIN32)
+#if defined(_WIN64)
     unsigned long r;
     _BitScanReverse64(&r, x);
     return 63 - r;
+#elif defined(_WIN32)
+    unsigned long x1 = (u32)x;
+    unsigned long x2 = (u32)(x >> 32);
+    unsigned long r;
+    if (x2) {
+        _BitScanReverse(&r, x2);
+        return (u32)(31 - r);
+    }
+    _BitScanReverse(&r, (u32)x1);
+    return (u32)(63 - r);
 #else
     return (u32)__builtin_clzll(x);
 #endif
@@ -111,10 +121,17 @@ u32 ctz32(u32 x) {
 static really_inline
 u32 ctz64(u64a x) {
     assert(x); // behaviour not defined for x == 0
-#if defined(_WIN32)
+#if defined(_WIN64)
     unsigned long r;
     _BitScanForward64(&r, x);
     return r;
+#elif defined(_WIN32)
+    unsigned long r;
+    if (_BitScanForward(&r, (u32)x)) {
+        return (u32)r;
+    }
+    _BitScanForward(&r, x >> 32);
+    return (u32)(r + 32);
 #else
     return (u32)__builtin_ctzll(x);
 #endif
@@ -177,8 +194,8 @@ u32 findAndClearLSB_64(u64a *v) {
 #else
     // fall back to doing things with two 32-bit cases, since gcc-4.1 doesn't
     // inline calls to __builtin_ctzll
-    u32 v1 = *v;
-    u32 v2 = (*v >> 32);
+    u32 v1 = (u32)*v;
+    u32 v2 = (u32)(*v >> 32);
     u32 offset;
     if (v1) {
         offset = findAndClearLSB_32(&v1);
@@ -233,7 +250,7 @@ u32 findAndClearMSB_64(u64a *v) {
 #else
     // fall back to doing things with two 32-bit cases, since gcc-4.1 doesn't
     // inline calls to __builtin_ctzll
-    u32 v1 = *v;
+    u32 v1 = (u32)*v;
     u32 v2 = (*v >> 32);
     u32 offset;
     if (v2) {
diff --git a/src/util/charreach.cpp b/src/util/charreach.cpp
index a231bbb0..9116b719 100644
--- a/src/util/charreach.cpp
+++ b/src/util/charreach.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -50,44 +50,6 @@ void CharReach::set(const std::string &s) {
     }
 }
 
-/// Bitwise OR.
-CharReach CharReach::operator|(const CharReach &a) const {
-    CharReach cr(*this);
-    cr.bits |= a.bits;
-    return cr;
-}
-
-/// Bitwise OR-equals.
-void CharReach::operator|=(const CharReach &a) {
-    bits |= a.bits;
-}
-
-/// Bitwise AND.
-CharReach CharReach::operator&(const CharReach &a) const {
-    CharReach cr(*this);
-    cr.bits &= a.bits;
-    return cr;
-}
-
-/// Bitwise AND-equals.
-void CharReach::operator&=(const CharReach &a) {
-    bits &= a.bits;
-}
-
-/// Bitwise complement.
-CharReach CharReach::operator~(void) const {
-    CharReach cr(*this);
-    cr.flip();
-    return cr;
-}
-
-/// Bitwise XOR.
-CharReach CharReach::operator^(const CharReach &a) const {
-    CharReach cr(*this);
-    cr.bits ^= a.bits;
-    return cr;
-}
-
 /// Do we only contain bits representing alpha characters?
 bool CharReach::isAlpha() const {
     if (none()) {
diff --git a/src/util/charreach.h b/src/util/charreach.h
index 64bd969e..53f2a5d2 100644
--- a/src/util/charreach.h
+++ b/src/util/charreach.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -135,22 +135,38 @@ public:
     size_t find_nth(size_t n) const { return bits.find_nth(n); }
 
     /// Bitwise OR.
-    CharReach operator|(const CharReach &a) const;
+    CharReach operator|(const CharReach &a) const {
+        CharReach cr(*this);
+        cr.bits |= a.bits;
+        return cr;
+    }
 
     /// Bitwise OR-equals.
-    void operator|=(const CharReach &a);
+    void operator|=(const CharReach &a) { bits |= a.bits; }
 
     /// Bitwise AND.
-    CharReach operator&(const CharReach &a) const;
+    CharReach operator&(const CharReach &a) const {
+        CharReach cr(*this);
+        cr.bits &= a.bits;
+        return cr;
+    }
 
     /// Bitwise AND-equals.
-    void operator&=(const CharReach &a);
+    void operator&=(const CharReach &a) { bits &= a.bits; }
 
     /// Bitwise XOR.
-    CharReach operator^(const CharReach &a) const;
+    CharReach operator^(const CharReach &a) const {
+        CharReach cr(*this);
+        cr.bits ^= a.bits;
+        return cr;
+    }
 
     /// Bitwise complement.
-    CharReach operator~(void) const;
+    CharReach operator~(void) const {
+        CharReach cr(*this);
+        cr.flip();
+        return cr;
+    }
 
     /// Do we only contain bits representing alpha characters?
     bool isAlpha() const;
diff --git a/src/util/charreach_util.h b/src/util/charreach_util.h
index 47f76a3f..f0dc4227 100644
--- a/src/util/charreach_util.h
+++ b/src/util/charreach_util.h
@@ -29,43 +29,11 @@
 #ifndef CHARREACH_UTIL_H
 #define CHARREACH_UTIL_H
 
-#include <map>
-#include <set>
-
-#include "charreach.h"
+#include "ue2common.h"
 
 namespace ue2 {
 
-template<typename T>
-std::map<CharReach, std::set<T> >
-make_disjoint(const std::map<CharReach, std::set<T> > &in) {
-    using namespace std;
-
-    map<u8, set<T> > by_char;
-    for (typename map<CharReach, set<T> >::const_iterator it = in.begin();
-         it != in.end(); ++it) {
-        const CharReach &cr = it->first;
-        for (size_t j = cr.find_first(); j != CharReach::npos;
-             j = cr.find_next(j)) {
-            by_char[j].insert(it->second.begin(), it->second.end());
-        }
-    }
-
-    map<set<T>, CharReach> rev;
-    for (typename map<u8, set<T> >::const_iterator it = by_char.begin();
-         it != by_char.end(); ++it) {
-        rev[it->second].set(it->first);
-    }
-
-    map<CharReach, set<T> > out;
-    for (typename map<set<T>, CharReach>::const_iterator it = rev.begin();
-         it != rev.end(); ++it) {
-        assert(out.find(it->second) == out.end());
-        out[it->second] = it->first;
-    }
-
-    return out;
-}
+class CharReach;
 
 void make_caseless(CharReach *cr);
 
diff --git a/src/util/compare.h b/src/util/compare.h
index 11c01f08..eaa717a4 100644
--- a/src/util/compare.h
+++ b/src/util/compare.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -97,9 +97,10 @@ u64a theirtoupper64(const u64a x) {
 
 static really_inline
 int cmpNocaseNaive(const u8 *p1, const u8 *p2, size_t len) {
-    const u8 *pEnd = (const u8 *)p1 + len;
+    const u8 *pEnd = p1 + len;
     for (; p1 < pEnd; p1++, p2++) {
-        if (mytolower(*p1) != mytolower(*p2)) {
+        assert(!ourisalpha(*p2) || myisupper(*p2)); // Already upper-case.
+        if ((u8)mytoupper(*p1) != *p2) {
             return 1;
         }
     }
@@ -108,7 +109,7 @@ int cmpNocaseNaive(const u8 *p1, const u8 *p2, size_t len) {
 
 static really_inline
 int cmpCaseNaive(const u8 *p1, const u8 *p2, size_t len) {
-    const u8 *pEnd = (const u8 *)p1 + len;
+    const u8 *pEnd = p1 + len;
     for (; p1 < pEnd; p1++, p2++) {
         if (*p1 != *p2) {
             return 1;
@@ -129,6 +130,11 @@ int cmpCaseNaive(const u8 *p1, const u8 *p2, size_t len) {
 
 #define CMP_SIZE sizeof(CMP_T)
 
+/**
+ * \brief Compare two strings, optionally caselessly.
+ *
+ * Note: If nocase is true, p2 is assumed to be already upper-case.
+ */
 #if defined(ARCH_IA32)
 static UNUSED never_inline
 #else
@@ -145,11 +151,13 @@ int cmpForward(const u8 *p1, const u8 *p2, size_t len, char nocase) {
 
     if (nocase) { // Case-insensitive version.
         for (; p1 < p1_end; p1 += CMP_SIZE, p2 += CMP_SIZE) {
-            if (TOUPPER(ULOAD(p1)) != TOUPPER(ULOAD(p2))) {
+            assert(ULOAD(p2) == TOUPPER(ULOAD(p2))); // Already upper-case.
+            if (TOUPPER(ULOAD(p1)) != ULOAD(p2)) {
                 return 1;
             }
         }
-        if (TOUPPER(ULOAD(p1_end)) != TOUPPER(ULOAD(p2_end))) {
+        assert(ULOAD(p2_end) == TOUPPER(ULOAD(p2_end))); // Already upper-case.
+        if (TOUPPER(ULOAD(p1_end)) != ULOAD(p2_end)) {
             return 1;
         }
     } else { // Case-sensitive version.
diff --git a/src/util/container.h b/src/util/container.h
index 62e841c1..63e27743 100644
--- a/src/util/container.h
+++ b/src/util/container.h
@@ -100,8 +100,9 @@ std::set<typename C::key_type> assoc_keys(const C &container) {
 /**
  * \brief Return the length in bytes of the given vector of (POD) objects.
  */
-template<typename T>
-typename std::vector<T>::size_type byte_length(const std::vector<T> &vec) {
+template <typename T, typename Alloc>
+typename std::vector<T, Alloc>::size_type
+byte_length(const std::vector<T, Alloc> &vec) {
     static_assert(std::is_pod<T>::value, "should be pod");
     return vec.size() * sizeof(T);
 }
@@ -110,8 +111,8 @@ typename std::vector<T>::size_type byte_length(const std::vector<T> &vec) {
  * \brief Copy the given vector of POD objects to the given location in memory.
  * It is safe to give this function an empty vector.
  */
-template<typename T>
-void *copy_bytes(void *dest, const std::vector<T> &vec) {
+template<typename T, typename Alloc>
+void *copy_bytes(void *dest, const std::vector<T, Alloc> &vec) {
     static_assert(std::is_pod<T>::value, "should be pod");
     assert(dest);
 
diff --git a/src/util/cpuid_flags.c b/src/util/cpuid_flags.c
index 58cfeb32..9a8bd922 100644
--- a/src/util/cpuid_flags.c
+++ b/src/util/cpuid_flags.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -40,6 +40,8 @@
 #define SSSE3 (1 << 9)
 #define SSE4_1 (1 << 19)
 #define SSE4_2 (1 << 20)
+#define XSAVE (1 << 27)
+#define AVX (1 << 28)
 
 // EDX
 #define SSE (1 << 25)
@@ -51,6 +53,10 @@
 #define AVX2 (1 << 5)
 #define BMI2 (1 << 8)
 
+// Extended Control Register 0 (XCR0) values
+#define XCR0_SSE (1 << 1)
+#define XCR0_AVX (1 << 2)
+
 static __inline
 void cpuid(unsigned int op, unsigned int leaf, unsigned int *eax,
            unsigned int *ebx, unsigned int *ecx, unsigned int *edx) {
@@ -66,19 +72,61 @@ void cpuid(unsigned int op, unsigned int leaf, unsigned int *eax,
 #endif
 }
 
-u64a cpuid_flags(void) {
-    unsigned int eax, ebx, ecx, edx;
-    u64a cap = 0;
+static inline
+u64a xgetbv(u32 op) {
+#if defined(_WIN32) || defined(__INTEL_COMPILER)
+    return _xgetbv(op);
+#else
+    u32 a, d;
+    __asm__ volatile (
+            "xgetbv\n"
+            : "=a"(a),
+              "=d"(d)
+            : "c"(op));
+    return ((u64a)d << 32) + a;
+#endif
+}
+
+static
+int check_avx2(void) {
+#if defined(__INTEL_COMPILER)
+    return _may_i_use_cpu_feature(_FEATURE_AVX2);
+#else
+    unsigned int eax, ebx, ecx, edx;
 
-    // version info
     cpuid(1, 0, &eax, &ebx, &ecx, &edx);
 
-    /* ECX and EDX contain capability flags */
+    /* check AVX is supported and XGETBV is enabled by OS */
+    if ((ecx & (AVX | XSAVE)) != (AVX | XSAVE)) {
+        DEBUG_PRINTF("AVX and XSAVE not supported\n");
+        return 0;
+    }
 
+    /* check that SSE and AVX registers are enabled by OS */
+    u64a xcr0 = xgetbv(0);
+    if ((xcr0 & (XCR0_SSE | XCR0_AVX)) != (XCR0_SSE | XCR0_AVX)) {
+        DEBUG_PRINTF("SSE and AVX registers not enabled\n");
+        return 0;
+    }
+
+    /* ECX and EDX contain capability flags */
     ecx = 0;
     cpuid(7, 0, &eax, &ebx, &ecx, &edx);
 
     if (ebx & AVX2) {
+        DEBUG_PRINTF("AVX2 enabled\n");
+        return 1;
+    }
+
+    return 0;
+#endif
+}
+
+u64a cpuid_flags(void) {
+    u64a cap = 0;
+
+    if (check_avx2()) {
+        DEBUG_PRINTF("AVX2 enabled\n");
         cap |= HS_CPU_FEATURES_AVX2;
     }
 
diff --git a/src/util/dump_charclass.cpp b/src/util/dump_charclass.cpp
index 2cadc67a..74b45414 100644
--- a/src/util/dump_charclass.cpp
+++ b/src/util/dump_charclass.cpp
@@ -72,8 +72,10 @@ void describeChar(ostream &os, char c, enum cc_output_t out_type) {
     } else if (c == 0x0d) {
         os << backslash << 'r';
     } else {
+        auto fmt(os.flags());
         os << backslash << 'x' << std::hex << std::setw(2)
-           << std::setfill('0') << (unsigned)(c & 0xff) << std::dec;
+           << std::setfill('0') << (unsigned)(c & 0xff);
+        os.flags(fmt);
     }
 }
 
diff --git a/src/util/dump_charclass.h b/src/util/dump_charclass.h
index d2a71880..9c3362bc 100644
--- a/src/util/dump_charclass.h
+++ b/src/util/dump_charclass.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -48,8 +48,8 @@ enum cc_output_t {
 
 class CharReach;
 
-void describeClass(std::ostream &os, const CharReach &cr, size_t maxLength,
-                   enum cc_output_t out_type);
+void describeClass(std::ostream &os, const CharReach &cr, size_t maxLength = 16,
+                   enum cc_output_t out_type  = CC_OUT_TEXT);
 
 std::string describeClass(const CharReach &cr, size_t maxLength = 16,
                           enum cc_output_t out_type = CC_OUT_TEXT);
diff --git a/src/util/exhaust.h b/src/util/exhaust.h
index e75d1809..b55c52d7 100644
--- a/src/util/exhaust.h
+++ b/src/util/exhaust.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -34,65 +34,46 @@
 #define EXHAUST_H
 
 #include "rose/rose_internal.h"
+#include "util/multibit.h"
 #include "ue2common.h"
-#include <string.h>
 
-/** \brief Sentinel value meaning no further exhaustion keys. */
-#define END_EXHAUST (~(u32)0)
+/** Index meaning a given exhaustion key is invalid. */
+#define INVALID_EKEY    (~(u32)0)
 
-/** \brief Test whether the given key (\a eoff) is set in the exhaustion vector
+/** \brief Test whether the given key (\a ekey) is set in the exhaustion vector
  * \a evec. */
 static really_inline
-int isExhausted(const char *evec, u32 eoff) {
-    DEBUG_PRINTF("checking exhaustion %p %u\n", evec, eoff);
-    return eoff != END_EXHAUST && (evec[eoff >> 3] & (1 << (eoff % 8)));
+int isExhausted(const struct RoseEngine *t, const char *evec, u32 ekey) {
+    DEBUG_PRINTF("checking exhaustion %p %u\n", evec, ekey);
+    assert(ekey != INVALID_EKEY);
+    assert(ekey < t->ekeyCount);
+    return mmbit_isset((const u8 *)evec, t->ekeyCount, ekey);
 }
 
 /** \brief Returns 1 if all exhaustion keys in the bitvector are on. */
 static really_inline
-int isAllExhausted(const struct RoseEngine *t, const char *evec_in) {
+int isAllExhausted(const struct RoseEngine *t, const char *evec) {
     if (!t->canExhaust) {
         return 0; /* pattern set is inexhaustible */
     }
 
-    const u8 *evec = (const u8 *)evec_in;
-
-    u32 whole_bytes = t->ekeyCount / 8;
-    for (u32 i = 0; i < whole_bytes; i++) {
-        if (evec[i] != 0xff) {
-            DEBUG_PRINTF("unexhausted pattern in byte %u\n", i);
-            return 0;
-        }
-    }
-
-    u32 rem = t->ekeyCount % 8;
-    if (t->ekeyCount % 8) {
-        u8 mask = (1 << rem) - 1;
-        if (evec[whole_bytes] != (char)mask) {
-            DEBUG_PRINTF("unexhausted pattern (%hhu) in final byte\n", mask);
-            return 0;
-        }
-    }
-
-    DEBUG_PRINTF("pattern set is exhausted\n");
-    return 1;
+    return mmbit_all((const u8 *)evec, t->ekeyCount);
 }
 
-/** \brief Mark key \a eoff on in the exhaustion vector. */
+/** \brief Mark key \a ekey on in the exhaustion vector. */
 static really_inline
-void markAsMatched(char *evec, u32 eoff) {
-    if (eoff != END_EXHAUST) {
-        DEBUG_PRINTF("marking as exhausted key %u\n", eoff);
-        evec[eoff >> 3] |= 1 << (eoff % 8);
-    }
+void markAsMatched(const struct RoseEngine *t, char *evec, u32 ekey) {
+    DEBUG_PRINTF("marking as exhausted key %u\n", ekey);
+    assert(ekey != INVALID_EKEY);
+    assert(ekey < t->ekeyCount);
+    mmbit_set((u8 *)evec, t->ekeyCount, ekey);
 }
 
 /** \brief Clear all keys in the exhaustion vector. */
 static really_inline
-void clearEvec(char *ev, const struct RoseEngine *t) {
-    size_t size = (t->ekeyCount + 7) / 8;
-    DEBUG_PRINTF("clearing evec %p %zu\n", ev, size);
-    memset(ev, 0, size);
+void clearEvec(const struct RoseEngine *t, char *evec) {
+    DEBUG_PRINTF("clearing evec %p %u\n", evec, t->ekeyCount);
+    mmbit_clear((u8 *)evec, t->ekeyCount);
 }
 
 #endif
diff --git a/src/util/fatbit.h b/src/util/fatbit.h
index cf906269..ad607638 100644
--- a/src/util/fatbit.h
+++ b/src/util/fatbit.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -58,21 +58,25 @@ void fatbit_clear(struct fatbit *bits) {
 
 static really_inline
 char fatbit_set(struct fatbit *bits, u32 total_bits, u32 key) {
+    assert(ISALIGNED(bits));
     return mmbit_set(bits->fb_int.raw, total_bits, key);
 }
 
 static really_inline
 void fatbit_unset(struct fatbit *bits, u32 total_bits, u32 key) {
+    assert(ISALIGNED(bits));
      mmbit_unset(bits->fb_int.raw, total_bits, key);
 }
 
 static really_inline
 char fatbit_isset(const struct fatbit *bits, u32 total_bits, u32 key) {
+    assert(ISALIGNED(bits));
     return mmbit_isset(bits->fb_int.raw, total_bits, key);
 }
 
 static really_inline
 u32 fatbit_iterate(const struct fatbit *bits, u32 total_bits, u32 it_in) {
+    assert(ISALIGNED(bits));
     /* TODO: iterate_flat could be specialised as we don't have to worry about
      * partial blocks. */
     return mmbit_iterate(bits->fb_int.raw, total_bits, it_in);
diff --git a/src/util/internal_report.h b/src/util/internal_report.h
deleted file mode 100644
index 1ed44ba2..00000000
--- a/src/util/internal_report.h
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright (c) 2015, Intel Corporation
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of Intel Corporation nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/** \file
- * \brief Definition of an internal_report, along with convenience functions.
- */
-
-#ifndef INTERNAL_REPORT_H
-#define INTERNAL_REPORT_H
-
-#include "ue2common.h"
-
-/* internal_report::type values */
-
-#define EXTERNAL_CALLBACK                             0
-#define EXTERNAL_CALLBACK_SOM_REL                     1
-#define INTERNAL_SOM_LOC_SET                          2
-#define INTERNAL_SOM_LOC_SET_IF_UNSET                 3
-#define INTERNAL_SOM_LOC_SET_IF_WRITABLE              4
-#define INTERNAL_SOM_LOC_SET_SOM_REV_NFA              5
-#define INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET     6
-#define INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE  7
-#define INTERNAL_SOM_LOC_COPY                         8
-#define INTERNAL_SOM_LOC_COPY_IF_WRITABLE             9
-#define INTERNAL_SOM_LOC_MAKE_WRITABLE               10
-#define EXTERNAL_CALLBACK_SOM_STORED                 11
-#define EXTERNAL_CALLBACK_SOM_ABS                    12
-#define EXTERNAL_CALLBACK_SOM_REV_NFA                13
-
-/** set the som loc to the value in from_offset */
-#define INTERNAL_SOM_LOC_SET_FROM                    14
-
-/** set the som loc to the value in from_offset */
-#define INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE        15
-#define INTERNAL_ROSE_CHAIN                          16
-
-/** Index meaning a given exhaustion key is invalid. */
-#define INVALID_EKEY      0xffffffff
-
-/** \brief All the data we use for handling a match, bytecode representation.
- *
- * Includes extparam constraints and bounds, exhaustion/dedupe keys, offset
- * adjustment and SOM information.
- *
- * At compile time, this data is in the ue2::Report structure, which is
- * converted to internal_report for layout in the bytecode.
- */
-struct ALIGN_CL_DIRECTIVE internal_report {
-    /** \brief from EXTERNAL_ and INTERNAL_ defined above. */
-    u8 type;
-
-    /** \brief do we actually use minOffset, maxOffset */
-    u8 hasBounds;
-
-    /** \brief use SOM for minLength, but don't report it to user callback. */
-    u8 quashSom;
-
-    /** \brief min offset in the stream at which this report can match. */
-    u64a minOffset;
-
-    /** \brief max offset in the stream at which this report can match. */
-    u64a maxOffset;
-
-    /** \brief min match length (start of match to current offset) */
-    u64a minLength;
-
-    /** \brief Exhaustion key.
-     *
-     * If exhaustible, the ekey to check before reporting a match.
-     * Additionally after reporting a match the ekey will be set. If not
-     * exhaustible, this will be INVALID_EKEY. */
-    u32 ekey;
-
-    /** \brief Dedupe key. */
-    u32 dkey;
-
-    /** \brief Adjustment to add to the match offset when we report a match.
-     *
-     * This is usually used for reports attached to states that form part of a
-     * zero-width assertion, like '$'. */
-    s32 offsetAdjust;
-
-    /** \brief Match report ID, for external reports.
-     *
-     * - external callback -> external report id
-     * - internal_som_* -> som loc to modify,
-     * - INTERNAL_ROSE_CHAIN -> top event to push on
-     * - otherwise target subnfa. */
-    u32 onmatch;
-
-    union {
-        /** \brief SOM distance value, use varies according to type.
-         *
-         *  - for EXTERNAL_CALLBACK_SOM_REL, from-offset is this many bytes
-         *    before the to-offset.
-         *  - for EXTERNAL_CALLBACK_SOM_ABS, set from-offset to this value.
-         *  - for INTERNAL_SOM_LOC_COPY*, som location read_from.
-         */
-        u64a somDistance;
-
-        /** \brief Index of the reverse nfa.
-         * Used by EXTERNAL_CALLBACK_SOM_REV_NFA and
-         *  INTERNAL_SOM_LOC_SET_SOM_REV_NFA*
-         */
-        u64a revNfaIndex;
-
-        /**
-         * Used by INTERNAL_ROSE_CHAIN, Number of bytes behind us that we are
-         * allowed to squash identical top events on the queue.
-         */
-        u64a topSquashDistance;
-    } aux;
-};
-
-static really_inline
-int isInternalSomReport(const struct internal_report *ri) {
-    switch (ri->type) {
-    case INTERNAL_SOM_LOC_SET:
-    case INTERNAL_SOM_LOC_SET_IF_UNSET:
-    case INTERNAL_SOM_LOC_SET_IF_WRITABLE:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE:
-    case INTERNAL_SOM_LOC_COPY:
-    case INTERNAL_SOM_LOC_COPY_IF_WRITABLE:
-    case INTERNAL_SOM_LOC_MAKE_WRITABLE:
-    case INTERNAL_SOM_LOC_SET_FROM:
-    case INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE:
-        return 1;
-    case EXTERNAL_CALLBACK:
-    case EXTERNAL_CALLBACK_SOM_REL:
-    case EXTERNAL_CALLBACK_SOM_STORED:
-    case EXTERNAL_CALLBACK_SOM_ABS:
-    case EXTERNAL_CALLBACK_SOM_REV_NFA:
-    case INTERNAL_ROSE_CHAIN:
-        return 0;
-    default:
-        break; // fall through
-    }
-    assert(0); // unknown?
-    return 0;
-}
-
-#ifndef NDEBUG
-/* used in asserts */
-static UNUSED
-char isExternalReport(const struct internal_report *ir) {
-    switch (ir->type) {
-    case INTERNAL_SOM_LOC_SET:
-    case INTERNAL_SOM_LOC_SET_IF_UNSET:
-    case INTERNAL_SOM_LOC_SET_IF_WRITABLE:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE:
-    case INTERNAL_SOM_LOC_COPY:
-    case INTERNAL_SOM_LOC_COPY_IF_WRITABLE:
-    case INTERNAL_SOM_LOC_MAKE_WRITABLE:
-    case INTERNAL_SOM_LOC_SET_FROM:
-    case INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE:
-    case INTERNAL_ROSE_CHAIN:
-        return 0;
-    case EXTERNAL_CALLBACK:
-    case EXTERNAL_CALLBACK_SOM_REL:
-    case EXTERNAL_CALLBACK_SOM_STORED:
-    case EXTERNAL_CALLBACK_SOM_ABS:
-    case EXTERNAL_CALLBACK_SOM_REV_NFA:
-        return 1;
-    default:
-        break; // fall through
-    }
-    assert(0); // unknown?
-    return 1;
-}
-#endif
-
-#endif // INTERNAL_REPORT_H
diff --git a/src/util/join.h b/src/util/join.h
index 0bc79d9b..7d5a30c3 100644
--- a/src/util/join.h
+++ b/src/util/join.h
@@ -31,4 +31,10 @@
 #define JOIN(x, y) JOIN_AGAIN(x, y)
 #define JOIN_AGAIN(x, y) x ## y
 
+#define JOIN3(x, y, z) JOIN_AGAIN3(x, y, z)
+#define JOIN_AGAIN3(x, y, z) x ## y ## z
+
+#define JOIN4(w, x, y, z) JOIN_AGAIN4(w, x, y, z)
+#define JOIN_AGAIN4(w, x, y, z) w ## x ## y ## z
+
 #endif
diff --git a/src/util/masked_move.h b/src/util/masked_move.h
index c7bf04da..93c79e75 100644
--- a/src/util/masked_move.h
+++ b/src/util/masked_move.h
@@ -35,8 +35,14 @@
 #include "simd_utils.h"
 #include "simd_utils_ssse3.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 extern const u32 mm_mask_mask[16];
 extern const u32 mm_shuffle_end[32][8];
+#ifdef __cplusplus
+}
+#endif
 
 /* load mask for len bytes from start of buffer */
 static really_inline m256
diff --git a/src/util/multibit.h b/src/util/multibit.h
index 771c158d..ddc8bbdd 100644
--- a/src/util/multibit.h
+++ b/src/util/multibit.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -664,6 +664,84 @@ char mmbit_any_precise(const u8 *bits, u32 total_bits) {
     return mmbit_iterate_big(bits, total_bits, MMB_INVALID) != MMB_INVALID;
 }
 
+static really_inline
+char mmbit_all_flat(const u8 *bits, u32 total_bits) {
+    while (total_bits > MMB_KEY_BITS) {
+        if (mmb_load(bits) != MMB_ALL_ONES) {
+            return 0;
+        }
+        bits += sizeof(MMB_TYPE);
+        total_bits -= MMB_KEY_BITS;
+    }
+    while (total_bits > 8) {
+        if (*bits != 0xff) {
+            return 0;
+        }
+        bits++;
+        total_bits -= 8;
+    }
+    u8 mask = (u8)mmb_mask_zero_to_nocheck(total_bits);
+    return (*bits & mask) == mask;
+}
+
+static really_inline
+char mmbit_all_big(const u8 *bits, u32 total_bits) {
+    u32 ks = mmbit_keyshift(total_bits);
+
+    u32 level = 0;
+    for (;;) {
+        // Number of bits we expect to see switched on on this level.
+        u32 level_bits;
+        if (ks != 0) {
+            u32 next_level_width = MMB_KEY_BITS << (ks - MMB_KEY_SHIFT);
+            level_bits = ROUNDUP_N(total_bits, next_level_width) >> ks;
+        } else {
+            level_bits = total_bits;
+        }
+
+        const u8 *block_ptr = mmbit_get_level_root_const(bits, level);
+
+        // All full-size blocks should be all-ones.
+        while (level_bits >= MMB_KEY_BITS) {
+            MMB_TYPE block = mmb_load(block_ptr);
+            if (block != MMB_ALL_ONES) {
+                return 0;
+            }
+            block_ptr += sizeof(MMB_TYPE);
+            level_bits -= MMB_KEY_BITS;
+        }
+
+        // If we have bits remaining, we have a runt block on the end.
+        if (level_bits > 0) {
+            MMB_TYPE block = mmb_load(block_ptr);
+            MMB_TYPE mask = mmb_mask_zero_to_nocheck(level_bits);
+            if ((block & mask) != mask) {
+                return 0;
+            }
+        }
+
+        if (ks == 0) {
+            break;
+        }
+
+        ks -= MMB_KEY_SHIFT;
+        level++;
+    }
+
+    return 1;
+}
+
+/** \brief True if all keys are on. Guaranteed precise. */
+static really_inline
+char mmbit_all(const u8 *bits, u32 total_bits) {
+    MDEBUG_PRINTF("%p total_bits %u\n", bits, total_bits);
+
+    if (mmbit_is_flat_model(total_bits)) {
+        return mmbit_all_flat(bits, total_bits);
+    }
+    return mmbit_all_big(bits, total_bits);
+}
+
 static really_inline
 MMB_TYPE get_flat_masks(u32 base, u32 it_start, u32 it_end) {
     if (it_end <= base) {
@@ -742,7 +820,7 @@ u32 mmbit_iterate_bounded_big(const u8 *bits, u32 total_bits, u32 it_start, u32
     for (;;) {
         assert(level <= max_level);
 
-        u32 block_width = MMB_KEY_BITS << ks;
+        u64a block_width = MMB_KEY_BITS << ks;
         u64a block_base = key * block_width;
         u64a block_min = MAX(it_start, block_base);
         u64a block_max = MIN(it_end, block_base + block_width - 1);
diff --git a/src/util/popcount.h b/src/util/popcount.h
index 510a449a..d882a672 100644
--- a/src/util/popcount.h
+++ b/src/util/popcount.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -38,21 +38,17 @@
 // We have a native popcount where the compiler has defined __POPCNT__.
 #if defined(__POPCNT__)
 #define HAVE_POPCOUNT_INSTR
-#endif
-
-#if defined(_WIN32) && defined(__AVX__) // TODO: fix win preproc
+#elif defined(_WIN32) && defined(__AVX__) // TODO: fix win preproc
 #define HAVE_POPCOUNT_INSTR
-#define __builtin_popcount __popcnt
-#define __builtin_popcountll __popcnt64
 #endif
 
 static really_inline
 u32 popcount32(u32 x) {
 #if defined(HAVE_POPCOUNT_INSTR)
     // Single-instruction builtin.
-    return (u32)__builtin_popcount(x);
+    return _mm_popcnt_u32(x);
 #else
-    // Fast branch-free version from bit-twiddling hacks as most Intel
+    // Fast branch-free version from bit-twiddling hacks as older Intel
     // processors do not have a POPCNT instruction.
     x -= (x >> 1) & 0x55555555;
     x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
@@ -62,16 +58,18 @@ u32 popcount32(u32 x) {
 
 static really_inline
 u32 popcount64(u64a x) {
-#if defined(HAVE_POPCOUNT_INSTR)
+#if defined(ARCH_X86_64)
+# if defined(HAVE_POPCOUNT_INSTR)
     // Single-instruction builtin.
-    return (u32)__builtin_popcountll(x);
-#elif defined(ARCH_X86_64)
-    // Fast branch-free version from bit-twiddling hacks as most Intel
+    return (u32)_mm_popcnt_u64(x);
+# else
+    // Fast branch-free version from bit-twiddling hacks as older Intel
     // processors do not have a POPCNT instruction.
     x -= (x >> 1) & 0x5555555555555555;
     x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);
     x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f;
     return (x * 0x0101010101010101) >> 56;
+# endif
 #else
     // Synthesise from two 32-bit cases.
     return popcount32(x >> 32) + popcount32(x);
diff --git a/src/util/report.h b/src/util/report.h
index 0e5bccf8..24ecca9d 100644
--- a/src/util/report.h
+++ b/src/util/report.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -34,31 +34,49 @@
 #ifndef UTIL_REPORT_H
 #define UTIL_REPORT_H
 
-#include "internal_report.h"
+#include "util/exhaust.h" // for INVALID_EKEY
 #include "order_check.h"
 #include "ue2common.h"
 
 #include <cassert>
 
-struct internal_report;
-
 namespace ue2 {
 
 class ReportManager;
 
+enum ReportType {
+    EXTERNAL_CALLBACK,
+    EXTERNAL_CALLBACK_SOM_REL,
+    INTERNAL_SOM_LOC_SET,
+    INTERNAL_SOM_LOC_SET_IF_UNSET,
+    INTERNAL_SOM_LOC_SET_IF_WRITABLE,
+    INTERNAL_SOM_LOC_SET_SOM_REV_NFA,
+    INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET,
+    INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE,
+    INTERNAL_SOM_LOC_COPY,
+    INTERNAL_SOM_LOC_COPY_IF_WRITABLE,
+    INTERNAL_SOM_LOC_MAKE_WRITABLE,
+    EXTERNAL_CALLBACK_SOM_STORED,
+    EXTERNAL_CALLBACK_SOM_ABS,
+    EXTERNAL_CALLBACK_SOM_REV_NFA,
+    INTERNAL_SOM_LOC_SET_FROM,
+    INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE,
+    INTERNAL_ROSE_CHAIN,
+    EXTERNAL_CALLBACK_SOM_PASS
+};
+
 /**
  * \brief All the data we use for handling a match.
  *
  * Includes extparam constraints and bounds, exhaustion/dedupe keys, offset
  * adjustment and SOM information.
  *
- * The data in this structure is converted into an \ref internal_report in the
- * bytecode.
+ * The data in this structure eventually becomes a list of Rose programs
+ * instructions.
  */
 struct Report {
-    Report(u8 type_in, u32 onmatch_in) : type(type_in), onmatch(onmatch_in) {
-        assert(type <= INTERNAL_ROSE_CHAIN);
-    }
+    Report(ReportType type_in, u32 onmatch_in)
+        : type(type_in), onmatch(onmatch_in) {}
 
     /** \brief True if this report has bounds from extended parameters, i.e.
      * min offset, max offset, min length. */
@@ -66,8 +84,8 @@ struct Report {
         return minOffset > 0 || maxOffset < MAX_OFFSET || minLength > 0;
     }
 
-    /** \brief from EXTERNAL_ and INTERNAL_ defined in internal_report.h. */
-    u8 type;
+    /** \brief Type of this report. */
+    ReportType type;
 
     /** \brief use SOM for minLength, but don't report it to user callback. */
     bool quashSom = false;
@@ -126,35 +144,6 @@ struct Report {
     u64a topSquashDistance = 0;
 };
 
-static inline
-bool isInternalSomReport(const Report &r) {
-    switch (r.type) {
-    case INTERNAL_SOM_LOC_SET:
-    case INTERNAL_SOM_LOC_SET_IF_UNSET:
-    case INTERNAL_SOM_LOC_SET_IF_WRITABLE:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET:
-    case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE:
-    case INTERNAL_SOM_LOC_COPY:
-    case INTERNAL_SOM_LOC_COPY_IF_WRITABLE:
-    case INTERNAL_SOM_LOC_MAKE_WRITABLE:
-    case INTERNAL_SOM_LOC_SET_FROM:
-    case INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE:
-        return true;
-    case EXTERNAL_CALLBACK:
-    case EXTERNAL_CALLBACK_SOM_REL:
-    case EXTERNAL_CALLBACK_SOM_STORED:
-    case EXTERNAL_CALLBACK_SOM_ABS:
-    case EXTERNAL_CALLBACK_SOM_REV_NFA:
-    case INTERNAL_ROSE_CHAIN:
-        return false;
-    default:
-        break; // fall through
-    }
-    assert(0); // unknown?
-    return false;
-}
-
 static inline
 bool isExternalReport(const Report &r) {
     switch (r.type) {
@@ -176,6 +165,7 @@ bool isExternalReport(const Report &r) {
     case EXTERNAL_CALLBACK_SOM_STORED:
     case EXTERNAL_CALLBACK_SOM_ABS:
     case EXTERNAL_CALLBACK_SOM_REV_NFA:
+    case EXTERNAL_CALLBACK_SOM_PASS:
         return true;
     default:
         break; // fall through
@@ -184,6 +174,11 @@ bool isExternalReport(const Report &r) {
     return true;
 }
 
+static inline
+bool isExternalSomReport(const Report &r) {
+    return r.type != EXTERNAL_CALLBACK && isExternalReport(r);
+}
+
 static inline
 bool operator<(const Report &a, const Report &b) {
     ORDER_CHECK(type);
@@ -223,7 +218,7 @@ Report makeSomRelativeCallback(u32 report, s32 offsetAdjust, u64a distance) {
 }
 
 static inline
-Report makeRoseTrigger(u32 event, u64a squashDistance) {
+Report makeMpvTrigger(u32 event, u64a squashDistance) {
     Report ir(INTERNAL_ROSE_CHAIN, event);
     ir.ekey = INVALID_EKEY;
     ir.topSquashDistance = squashDistance;
@@ -249,22 +244,6 @@ bool isSimpleExhaustible(const Report &ir) {
     return true;
 }
 
-/** True if this report requires some of the more esoteric processing in the
- * rose adaptor, rather than just firing a callback or doing SOM handling.
- */
-static inline
-bool isComplexReport(const Report &ir) {
-    if (ir.hasBounds() || ir.ekey != INVALID_EKEY) {
-        return true;
-    }
-
-    return false;
-}
-
-/** \brief Write the given Report into an internal_report structure. */
-void writeInternalReport(const Report &report, const ReportManager &rm,
-                         internal_report *ir);
-
 } // namespace
 
 #endif // UTIL_REPORT_H
diff --git a/src/util/report_manager.cpp b/src/util/report_manager.cpp
index 425f166d..8377ea03 100644
--- a/src/util/report_manager.cpp
+++ b/src/util/report_manager.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -217,6 +217,18 @@ Report ReportManager::getBasicInternalReport(const NGWrapper &g, s32 adj) {
     return makeECallback(g.reportId, adj, ekey);
 }
 
+void ReportManager::setProgramOffset(ReportID id, u32 programOffset) {
+    assert(id < reportIds.size());
+    assert(!contains(reportIdToProgramOffset, id));
+    reportIdToProgramOffset.emplace(id, programOffset);
+}
+
+u32 ReportManager::getProgramOffset(ReportID id) const {
+    assert(id < reportIds.size());
+    assert(contains(reportIdToProgramOffset, id));
+    return reportIdToProgramOffset.at(id);
+}
+
 static
 void ekeysUnion(std::set<u32> *ekeys, u32 more) {
     if (!ekeys->empty()) {
diff --git a/src/util/report_manager.h b/src/util/report_manager.h
index 4fb68aac..0eed2711 100644
--- a/src/util/report_manager.h
+++ b/src/util/report_manager.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -113,6 +113,14 @@ public:
      * ~0U if no dkey is needed. */
     u32 getDkey(const Report &r) const;
 
+    /** \brief Register a Rose program offset with the given report. */
+    void setProgramOffset(ReportID id, u32 programOffset);
+
+    /** \brief Fetch the program offset for a given report. It is a fatal error
+     * for this to be called with a report for which no program offset has been
+     * set. */
+    u32 getProgramOffset(ReportID id) const;
+
 private:
     /** \brief Grey box ref, for checking resource limits. */
     const Grey &grey;
@@ -127,6 +135,9 @@ private:
     /** \brief Mapping from ReportID to dedupe key. */
     std::map<ReportID, u32> reportIdToDedupeKey;
 
+    /** \brief Mapping from ReportID to Rose program offset in bytecode. */
+    std::map<ReportID, u32> reportIdToProgramOffset;
+
     /** \brief Mapping from external match ids to information about that
      * id. */
     std::map<ReportID, external_report_info> externalIdMap;
diff --git a/src/util/simd_utils.h b/src/util/simd_utils.h
index 8176e7e1..99ad7ce5 100644
--- a/src/util/simd_utils.h
+++ b/src/util/simd_utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -199,6 +199,7 @@ static really_inline m128 shiftLeft8Bits(m128 a) {
 }
 
 #define byteShiftRight128(a, count_immed) _mm_srli_si128(a, count_immed)
+#define byteShiftLeft128(a, count_immed) _mm_slli_si128(a, count_immed)
 
 #if !defined(__AVX2__)
 // TODO: this entire file needs restructuring - this carveout is awful
@@ -601,17 +602,6 @@ static really_inline m256 loadu256(const void *ptr) {
 #endif
 }
 
-// unaligned load of 128-bit value to low and high part of 256-bit value
-static really_inline m256 loadu2x128(const void *ptr) {
-#if defined(__AVX2__)
-    return set2x128(loadu128(ptr));
-#else
-    m256 rv;
-    rv.hi = rv.lo = loadu128(ptr);
-    return rv;
-#endif
-}
-
 // packed unaligned store of first N bytes
 static really_inline
 void storebytes256(void *ptr, m256 a, unsigned int n) {
diff --git a/src/sidecar/sidecar_shufti.h b/src/util/simd_utils_ssse3.c
similarity index 77%
rename from src/sidecar/sidecar_shufti.h
rename to src/util/simd_utils_ssse3.c
index 83e5e430..50cbe007 100644
--- a/src/sidecar/sidecar_shufti.h
+++ b/src/util/simd_utils_ssse3.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -26,13 +26,15 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SIDECAR_SHUFTI_H
-#define SIDECAR_SHUFTI_H
+#include "simd_utils_ssse3.h"
 
-#include "ue2common.h"
+const char vbs_mask_data[] ALIGN_CL_DIRECTIVE = {
+    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
 
-struct sidecar_S;
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 
-u8 sidecarExec_S_int(const struct sidecar_S *n, const u8 *b, size_t len,
-                     u8 state_in);
-#endif
+    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+};
diff --git a/src/util/simd_utils_ssse3.h b/src/util/simd_utils_ssse3.h
index 23c77d22..6854ade3 100644
--- a/src/util/simd_utils_ssse3.h
+++ b/src/util/simd_utils_ssse3.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -77,22 +77,35 @@ m128 pshufb(m128 a, m128 b) {
     return result;
 }
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern const char vbs_mask_data[];
+#ifdef __cplusplus
+}
+#endif
+
+static really_inline
+m128 variable_byte_shift_m128(m128 in, s32 amount) {
+    assert(amount >= -16 && amount <= 16);
+    m128 shift_mask = loadu128(vbs_mask_data + 16 - amount);
+    return pshufb(in, shift_mask);
+}
+
 #if defined(__AVX2__)
 
 static really_inline
 m256 vpshufb(m256 a, m256 b) {
     return _mm256_shuffle_epi8(a, b);
 }
+
 #if defined(USE_GCC_COMPOUND_STATEMENTS)
 #define vpalignr(r, l, offset) ({                   \
     m256 res = _mm256_alignr_epi8(r, l, offset);    \
     res;                                            \
 })
 #else
-static really_inline
-m256 vpalignr(m256 r, m256 l, const int offset) {
-    return _mm256_alignr_epi8(r, l, offset);
-}
+#define vpalignr(r, l, offset) _mm256_alignr_epi8(r, l, offset)
 #endif
 
 #else // not __AVX2__
diff --git a/src/util/ue2string.cpp b/src/util/ue2string.cpp
index 4b166196..7c16aa58 100644
--- a/src/util/ue2string.cpp
+++ b/src/util/ue2string.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -129,7 +129,9 @@ string dumpString(const ue2_literal &lit) {
 #endif
 
 void upperString(string &s) {
-    transform(s.begin(), s.end(), s.begin(), (int(*)(int)) mytoupper);
+    for (auto &c : s) {
+        c = mytoupper(c);
+    }
 }
 
 size_t maxStringOverlap(const string &a, const string &b, bool nocase) {
@@ -173,7 +175,16 @@ size_t maxStringSelfOverlap(const string &a, bool nocase) {
 }
 
 u32 cmp(const char *a, const char *b, size_t len, bool nocase) {
-    return cmpForward((const u8 *)a, (const u8 *)b, len, nocase);
+    if (!nocase) {
+        return memcmp(a, b, len);
+    }
+
+    for (const auto *a_end = a + len; a < a_end; a++, b++) {
+        if (mytoupper(*a) != mytoupper(*b)) {
+            return 1;
+        }
+    }
+    return 0;
 }
 
 case_iter::case_iter(const ue2_literal &ss) : s(ss.get_string()),
diff --git a/src/util/uniform_ops.h b/src/util/uniform_ops.h
index 5fa6ab56..45ea4108 100644
--- a/src/util/uniform_ops.h
+++ b/src/util/uniform_ops.h
@@ -76,9 +76,6 @@
 #define storeu_u32(ptr, a)   unaligned_store_u32(ptr, a)
 #define storeu_u64a(ptr, a)  unaligned_store_u64a(ptr, a)
 #define storeu_m128(ptr, a)  storeu128(ptr, a)
-#define storeu_m256(ptr, a)  storeu256(ptr, a)
-#define storeu_m384(ptr, a)  storeu384(ptr, a)
-#define storeu_m512(ptr, a)  storeu512(ptr, a)
 
 #define zero_u8             0
 #define zero_u32            0
diff --git a/unit/CMakeLists.txt b/unit/CMakeLists.txt
index a8925a3c..a893d3d5 100644
--- a/unit/CMakeLists.txt
+++ b/unit/CMakeLists.txt
@@ -25,7 +25,7 @@ if(CXX_WUNUSED_VARIABLE)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-variable")
 endif()
 
-add_library(gtest ${gtest_SOURCES})
+add_library(gtest STATIC ${gtest_SOURCES})
 
 add_definitions(-DGTEST_HAS_PTHREAD=0 -DSRCDIR=${PROJECT_SOURCE_DIR})
 
@@ -47,6 +47,8 @@ set(unit_internal_SOURCES
     internal/limex_nfa.cpp
     internal/masked_move.cpp
     internal/multi_bit.cpp
+    internal/multiaccel_matcher.cpp
+    internal/multiaccel_shift.cpp
     internal/nfagraph_common.h
     internal/nfagraph_comp.cpp
     internal/nfagraph_equivalence.cpp
@@ -64,7 +66,6 @@ set(unit_internal_SOURCES
     internal/repeat.cpp
     internal/rose_build_merge.cpp
     internal/rvermicelli.cpp
-    internal/sidecar.cpp
     internal/simd_utils.cpp
     internal/shuffle.cpp
     internal/shufti.cpp
@@ -96,6 +97,7 @@ set(unit_hyperscan_SOURCES
     hyperscan/multi.cpp
     hyperscan/order.cpp
     hyperscan/scratch_op.cpp
+    hyperscan/scratch_in_use.cpp
     hyperscan/serialize.cpp
     hyperscan/single.cpp
     hyperscan/som.cpp
diff --git a/unit/hyperscan/arg_checks.cpp b/unit/hyperscan/arg_checks.cpp
index dbc692c5..d277a26b 100644
--- a/unit/hyperscan/arg_checks.cpp
+++ b/unit/hyperscan/arg_checks.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -404,7 +404,8 @@ TEST(HyperscanArgChecks, ScanStreamNoStreamID) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -430,8 +431,10 @@ TEST(HyperscanArgChecks, ScanStreamNoData) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_close_stream(stream, scratch, dummy_cb, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_close_stream(stream, scratch, dummy_cb, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -457,8 +460,10 @@ TEST(HyperscanArgChecks, ScanStreamNoScratch) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_close_stream(stream, scratch, dummy_cb, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_close_stream(stream, scratch, dummy_cb, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -479,7 +484,8 @@ TEST(HyperscanArgChecks, CloseStreamNoStream) {
     ASSERT_NE(HS_SUCCESS, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -544,7 +550,8 @@ TEST(HyperscanArgChecks, CloseStreamNoMatchNoStream) {
     ASSERT_NE(HS_SUCCESS, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -588,7 +595,8 @@ TEST(HyperscanArgChecks, ChangeStreamContext) {
 
     // teardown
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
 
 // hs_reset_stream: Call with no stream id
@@ -606,7 +614,8 @@ TEST(HyperscanArgChecks, ResetStreamNoId) {
 
     err = hs_reset_stream(nullptr, 0, scratch, dummy_cb, nullptr);
     ASSERT_EQ(HS_INVALID, err);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -632,7 +641,8 @@ TEST(HyperscanArgChecks, ResetStreamNoScratch) {
     ASSERT_EQ(HS_SUCCESS, err);
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -664,7 +674,8 @@ TEST(HyperscanArgChecks, CopyStreamNoToId) {
     ASSERT_EQ(HS_SUCCESS, err);
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -687,8 +698,10 @@ TEST(HyperscanArgChecks, ResetAndCopyStreamNoToId) {
     err = hs_reset_and_copy_stream(nullptr, stream, scratch, nullptr, nullptr);
     ASSERT_EQ(HS_INVALID, err);
 
-    hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_close_stream(stream, scratch, nullptr, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -711,8 +724,10 @@ TEST(HyperscanArgChecks, ResetAndCopyStreamNoFromId) {
     err = hs_reset_and_copy_stream(stream, nullptr, scratch, nullptr, nullptr);
     ASSERT_EQ(HS_INVALID, err);
 
-    hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_close_stream(stream, scratch, nullptr, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -735,8 +750,10 @@ TEST(HyperscanArgChecks, ResetAndCopyStreamSameToId) {
     err = hs_reset_and_copy_stream(stream, stream, scratch, nullptr, nullptr);
     ASSERT_EQ(HS_INVALID, err);
 
-    hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_close_stream(stream, scratch, nullptr, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -764,9 +781,12 @@ TEST(HyperscanArgChecks, ResetAndCopyStreamNoCallbackOrScratch) {
     err = hs_reset_and_copy_stream(stream_to, stream, nullptr, nullptr, nullptr);
     ASSERT_EQ(HS_SUCCESS, err);
 
-    hs_close_stream(stream_to, scratch, nullptr, nullptr);
-    hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_close_stream(stream_to, scratch, nullptr, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_close_stream(stream, scratch, nullptr, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -795,9 +815,12 @@ TEST(HyperscanArgChecks, ResetAndCopyStreamNoScratch) {
                                    nullptr);
     ASSERT_EQ(HS_INVALID, err);
 
-    hs_close_stream(stream_to, scratch, nullptr, nullptr);
-    hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_close_stream(stream_to, scratch, nullptr, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_close_stream(stream, scratch, nullptr, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -830,9 +853,12 @@ TEST(HyperscanArgChecks, ResetAndCopyStreamDiffDb) {
                                    nullptr);
     ASSERT_EQ(HS_INVALID, err);
 
-    hs_close_stream(stream_to, scratch, nullptr, nullptr);
-    hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_close_stream(stream_to, scratch, nullptr, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_close_stream(stream, scratch, nullptr, nullptr);
+    ASSERT_EQ(HS_SUCCESS, err);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
     hs_free_database(db2);
 }
@@ -854,7 +880,8 @@ TEST(HyperscanArgChecks, ScanBlockNoDatabase) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -878,7 +905,8 @@ TEST(HyperscanArgChecks, ScanBlockBrokenDatabaseMagic) {
     ASSERT_EQ(HS_INVALID, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     free(db);
 }
 
@@ -902,7 +930,8 @@ TEST(HyperscanArgChecks, ScanBlockBrokenDatabaseVersion) {
     ASSERT_EQ(HS_DB_VERSION_ERROR, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -926,7 +955,8 @@ TEST(HyperscanArgChecks, ScanBlockBrokenDatabaseBytecode) {
     ASSERT_EQ(HS_INVALID, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -947,7 +977,8 @@ TEST(HyperscanArgChecks, ScanBlockStreamingDatabase) {
     ASSERT_EQ(HS_DB_MODE_ERROR, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -967,7 +998,8 @@ TEST(HyperscanArgChecks, ScanBlockVectoredDatabase) {
     ASSERT_EQ(HS_DB_MODE_ERROR, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -989,7 +1021,8 @@ TEST(HyperscanArgChecks, ScanBlockNoData) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1026,7 +1059,8 @@ TEST(HyperscanArgChecks, ScanBlockNoHandler) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1049,7 +1083,8 @@ TEST(HyperscanArgChecks, ScanVectorNoDatabase) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1075,7 +1110,8 @@ TEST(HyperscanArgChecks, ScanVectorBrokenDatabaseMagic) {
     ASSERT_EQ(HS_INVALID, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     free(db);
 }
 
@@ -1101,7 +1137,8 @@ TEST(HyperscanArgChecks, ScanVectorBrokenDatabaseVersion) {
     ASSERT_EQ(HS_DB_VERSION_ERROR, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1127,7 +1164,8 @@ TEST(HyperscanArgChecks, ScanVectorBrokenDatabaseBytecode) {
     ASSERT_EQ(HS_INVALID, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1150,7 +1188,8 @@ TEST(HyperscanArgChecks, ScanVectorStreamingDatabase) {
     ASSERT_EQ(HS_DB_MODE_ERROR, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1172,7 +1211,8 @@ TEST(HyperscanArgChecks, ScanVectorBlockDatabase) {
     ASSERT_EQ(HS_DB_MODE_ERROR, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1195,7 +1235,8 @@ TEST(HyperscanArgChecks, ScanVectorNoDataArray) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1218,7 +1259,8 @@ TEST(HyperscanArgChecks, ScanVectorNoDataBlock) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1240,7 +1282,8 @@ TEST(HyperscanArgChecks, ScanVectorNoLenArray) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1281,7 +1324,8 @@ TEST(HyperscanArgChecks, ScanVectorNoHandler) {
     EXPECT_NE(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1421,7 +1465,8 @@ TEST(HyperscanArgChecks, AllocScratchBadDatabaseCRC) {
     hs_scratch_t *scratch = nullptr;
     err = hs_alloc_scratch(db, &scratch);
     ASSERT_EQ(HS_SUCCESS, err);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 
     // for want of a better case, corrupt the "middle byte" of the database.
     char *mid = (char *)db + len/2;
@@ -1959,7 +2004,8 @@ TEST(HyperscanArgChecks, ScratchSizeNoSize) {
     err = hs_scratch_size(scratch, nullptr);
     ASSERT_EQ(HS_INVALID, err);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -2039,7 +2085,8 @@ TEST(HyperscanArgChecks, ScanStreamBadScratch) {
     ASSERT_TRUE(scratch != nullptr);
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     free(local_garbage);
 }
 
@@ -2073,7 +2120,8 @@ TEST(HyperscanArgChecks, ResetStreamBadScratch) {
     ASSERT_TRUE(scratch != nullptr);
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     free(local_garbage);
 }
 
@@ -2116,7 +2164,8 @@ TEST(HyperscanArgChecks, ScanFreedScratch) {
     err = hs_alloc_scratch(db, &scratch);
     ASSERT_EQ(HS_SUCCESS, err);
     ASSERT_TRUE(scratch != NULL);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     err = hs_scan(db, "data", 4, 0, scratch, dummy_cb, 0);
     ASSERT_EQ(HS_INVALID, err);
     EXPECT_NE(HS_SCAN_TERMINATED, err);
@@ -2154,6 +2203,37 @@ TEST(HyperscanArgChecks, ExprInfoNullErrPtr) {
     EXPECT_TRUE(info == nullptr);
 }
 
+// hs_expression_ext_info: Compile a NULL pattern
+TEST(HyperscanArgChecks, ExprExtInfoNullExpression) {
+    hs_expr_info_t *info = nullptr;
+    hs_compile_error_t *compile_err = nullptr;
+    hs_error_t err =
+        hs_expression_ext_info(nullptr, 0, nullptr, &info, &compile_err);
+    EXPECT_EQ(HS_COMPILER_ERROR, err);
+    EXPECT_TRUE(info == nullptr);
+    EXPECT_TRUE(compile_err != nullptr);
+    hs_free_compile_error(compile_err);
+}
+
+// hs_expression_ext_info: NULL info block ptr
+TEST(HyperscanArgChecks, ExprExtInfoNullInfoPtr) {
+    hs_compile_error_t *compile_err = nullptr;
+    hs_error_t err =
+        hs_expression_ext_info("foobar", 0, nullptr, nullptr, &compile_err);
+    EXPECT_EQ(HS_COMPILER_ERROR, err);
+    EXPECT_TRUE(compile_err != nullptr);
+    hs_free_compile_error(compile_err);
+}
+
+// hs_expression_ext_info: No compiler error block
+TEST(HyperscanArgChecks, ExprExtInfoNullErrPtr) {
+    hs_expr_info_t *info = nullptr;
+    hs_error_t err =
+        hs_expression_ext_info("foobar", 0, nullptr, &info, nullptr);
+    EXPECT_EQ(HS_COMPILER_ERROR, err);
+    EXPECT_TRUE(info == nullptr);
+}
+
 TEST(HyperscanArgChecks, hs_free_database_null) {
     hs_error_t err = hs_free_database(nullptr);
     ASSERT_EQ(HS_SUCCESS, err);
diff --git a/unit/hyperscan/bad_patterns.txt b/unit/hyperscan/bad_patterns.txt
index fb2a2357..9fc3a413 100644
--- a/unit/hyperscan/bad_patterns.txt
+++ b/unit/hyperscan/bad_patterns.txt
@@ -117,7 +117,6 @@
 117:/[\x{ff]/ #Value in \x{...} sequence is non-hex or missing } at index 1.
 118:/foo/{min_offset=10,max_offset=9} #In hs_expr_ext, min_offset must be less than or equal to max_offset.
 120:/foo/{min_length=10,max_offset=9} #In hs_expr_ext, min_length must be less than or equal to max_offset.
-121:/.e(?:(((eEbd..(d[^Be]{1,7}|A)){8,22}aD.){7}|EecA?(?:\b)c|bB[Dd])){29,37}[adb](?:.|A|c|[BEA]|D)..((?:c|[Cba]))?([Ee]|D)B+(.|[dbB]|E|E).[EcCe]ce(?:C|D)dD[EA]Ac.[aE]d/smiHWP #Pattern too large.
 122:/ÀÀ/8 #Expression is not valid UTF-8.
 123:/hello \6 world/P #Invalid back reference to expression 6.
 124:/hello \6 world|dog/P #Invalid back reference to expression 6.
diff --git a/unit/hyperscan/behaviour.cpp b/unit/hyperscan/behaviour.cpp
index 98371c86..a816969c 100644
--- a/unit/hyperscan/behaviour.cpp
+++ b/unit/hyperscan/behaviour.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -118,7 +118,8 @@ TEST(HyperscanTestBehaviour, ScanSeveralGigabytesNoMatch) {
     ASSERT_EQ(HS_SUCCESS, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -197,7 +198,8 @@ TEST_P(HyperscanScanGigabytesMatch, StreamingMatch) {
     }
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -287,7 +289,8 @@ TEST_P(HyperscanScanGigabytesMatch, BlockMatch) {
     }
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -349,7 +352,8 @@ TEST(HyperscanTestBehaviour, StreamingThereCanBeOnlyOne) {
     ASSERT_EQ(HS_SUCCESS, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -379,7 +383,8 @@ TEST(HyperscanTestBehaviour, BlockThereCanBeOnlyOne) {
     EXPECT_EQ(1U, matchCount); // only one match
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -425,7 +430,8 @@ TEST_P(HyperscanLiteralLengthTest, FloatingBlock) {
     EXPECT_EQ(0U, matchCount); // no matches
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -463,7 +469,8 @@ TEST_P(HyperscanLiteralLengthTest, AnchoredBlock) {
 
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -505,7 +512,8 @@ TEST_P(CallbackReturnStop, Block) {
     ASSERT_EQ(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -543,7 +551,8 @@ TEST_P(CallbackReturnStop, Streaming) {
     ASSERT_EQ(HS_SUCCESS, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -575,7 +584,8 @@ TEST_P(CallbackReturnStop, Vectored) {
     ASSERT_EQ(HS_SCAN_TERMINATED, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -642,7 +652,8 @@ TEST(HyperscanTestBehaviour, SerializedDogfood1) {
     ASSERT_EQ(HS_SUCCESS, err);
     ASSERT_EQ(len, lastMatchTo);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db2);
 }
 
@@ -734,7 +745,8 @@ TEST(HyperscanTestBehaviour, SerializedDogfood2) {
     ASSERT_EQ(len2, lastMatchTo);
     ASSERT_EQ(ids[3], lastMatchId);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db2);
 }
 
@@ -805,7 +817,8 @@ TEST(HyperscanTestBehaviour, SerializedDogfood3) {
     ASSERT_EQ(HS_SUCCESS, err);
     ASSERT_EQ(len, lastMatchTo);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     free(mem);
 }
 
@@ -840,7 +853,8 @@ TEST(HyperscanTestBehaviour, CloseStreamMatch) {
     EXPECT_EQ(1U, matchCount); // our match was returned
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -876,7 +890,8 @@ TEST(HyperscanTestBehaviour, NoMainCB) {
     EXPECT_EQ(1U, matchCount); // our match was returned
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -913,7 +928,8 @@ TEST(HyperscanTestBehaviour, CloseStreamNoMatch) {
     EXPECT_EQ(0U, matchCount); // no match was returned
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -948,7 +964,8 @@ TEST(HyperscanTestBehaviour, CloseStreamAfterTermination) {
     ASSERT_EQ(HS_SUCCESS, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -976,7 +993,8 @@ TEST(HyperscanTestBehaviour, Vectored1) {
     EXPECT_EQ(1U, matchCount);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1004,7 +1022,8 @@ TEST(HyperscanTestBehaviour, Vectored2) {
     EXPECT_EQ(1U, matchCount);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1032,7 +1051,8 @@ TEST(HyperscanTestBehaviour, Vectored3) {
     EXPECT_EQ(1U, matchCount);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1060,7 +1080,8 @@ TEST(HyperscanTestBehaviour, Vectored4) {
     EXPECT_EQ(1U, matchCount);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1088,7 +1109,8 @@ TEST(HyperscanTestBehaviour, Vectored5) {
     EXPECT_EQ(0U, matchCount);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1116,7 +1138,8 @@ TEST(HyperscanTestBehaviour, Vectored6) {
     EXPECT_EQ(1U, matchCount);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1144,7 +1167,8 @@ TEST(HyperscanTestBehaviour, Vectored7) {
     EXPECT_EQ(1U, matchCount);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1189,7 +1213,8 @@ TEST(regression, UE_1005) {
               != c.matches.end());
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1293,7 +1318,8 @@ TEST(regression, UE_2762) {
                 c.matches.end());
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1333,7 +1359,8 @@ TEST(regression, UE_2763) {
                 c.matches.end());
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1378,7 +1405,8 @@ TEST(regression, UE_2798) {
                 c.matches.end());
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1403,7 +1431,8 @@ TEST(PcreSpace, NewPcre) {
     EXPECT_EQ(data.size(), matchCount); // all are spaces
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1428,7 +1457,8 @@ TEST(PcreSpace, NewPcreClass) {
     EXPECT_EQ(data.size(), matchCount); // all are spaces
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1453,7 +1483,8 @@ TEST(PcreSpace, NewPcreNeg) {
     EXPECT_EQ(0, matchCount); // no matches, all are spaces
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1478,7 +1509,8 @@ TEST(PcreSpace, NewPcreClassNeg) {
     EXPECT_EQ(0, matchCount); // no matches, all are spaces
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -1502,7 +1534,8 @@ TEST(Parser, NewlineTerminatedComment) {
     EXPECT_EQ(1, matchCount);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
diff --git a/unit/hyperscan/expr_info.cpp b/unit/hyperscan/expr_info.cpp
index 4d4a1c97..984104c5 100644
--- a/unit/hyperscan/expr_info.cpp
+++ b/unit/hyperscan/expr_info.cpp
@@ -42,6 +42,8 @@ namespace /* anonymous */ {
 
 struct expected_info {
     const char *pattern;
+    hs_expr_ext ext;
+
     unsigned min;
     unsigned max;
     char unordered_matches;
@@ -52,10 +54,25 @@ struct expected_info {
 class ExprInfop : public TestWithParam<expected_info> {
 };
 
-TEST_P(ExprInfop, width) {
+static
+void check_info(const expected_info &ei, const hs_expr_info_t *info) {
+    EXPECT_EQ(ei.min, info->min_width);
+    EXPECT_EQ(ei.max, info->max_width);
+    EXPECT_EQ(ei.unordered_matches, info->unordered_matches);
+    EXPECT_EQ(ei.matches_at_eod, info->matches_at_eod);
+    EXPECT_EQ(ei.matches_only_at_eod, info->matches_only_at_eod);
+}
+
+// Check with hs_expression_info function.
+TEST_P(ExprInfop, check_no_ext) {
     const expected_info &ei = GetParam();
     SCOPED_TRACE(ei.pattern);
 
+    if (ei.ext.flags) {
+        // This is an extparam test, skip it.
+        return;
+    }
+
     hs_expr_info_t *info = nullptr;
     hs_compile_error_t *c_err = nullptr;
     hs_error_t err = hs_expression_info(ei.pattern, 0, &info, &c_err);
@@ -63,54 +80,97 @@ TEST_P(ExprInfop, width) {
     ASSERT_TRUE(info != nullptr);
     ASSERT_TRUE(c_err == nullptr);
 
-    EXPECT_EQ(ei.min, info->min_width);
-    EXPECT_EQ(ei.max, info->max_width);
-    EXPECT_EQ(ei.unordered_matches, info->unordered_matches);
-    EXPECT_EQ(ei.matches_at_eod, info->matches_at_eod);
-    EXPECT_EQ(ei.matches_only_at_eod, info->matches_only_at_eod);
-
+    check_info(ei, info);
     free(info);
 }
 
+// Check with hs_expression_ext_info function.
+TEST_P(ExprInfop, check_ext) {
+    const expected_info &ei = GetParam();
+    SCOPED_TRACE(ei.pattern);
+
+    hs_expr_info_t *info = nullptr;
+    hs_compile_error_t *c_err = nullptr;
+    hs_error_t err =
+        hs_expression_ext_info(ei.pattern, 0, &ei.ext, &info, &c_err);
+    ASSERT_EQ(HS_SUCCESS, err);
+    ASSERT_TRUE(info != nullptr);
+    ASSERT_TRUE(c_err == nullptr);
+
+    check_info(ei, info);
+    free(info);
+}
+
+// Check with hs_expression_ext_info function and a nullptr ext param, for
+// cases where ext.flags == 0. Functionally identical to check_no_ext above.
+TEST_P(ExprInfop, check_ext_null) {
+    const expected_info &ei = GetParam();
+    SCOPED_TRACE(ei.pattern);
+
+    if (ei.ext.flags) {
+        // This is an extparam test, skip it.
+        return;
+    }
+
+    hs_expr_info_t *info = nullptr;
+    hs_compile_error_t *c_err = nullptr;
+    hs_error_t err =
+        hs_expression_ext_info(ei.pattern, 0, nullptr, &info, &c_err);
+    ASSERT_EQ(HS_SUCCESS, err);
+    ASSERT_TRUE(info != nullptr);
+    ASSERT_TRUE(c_err == nullptr);
+
+    check_info(ei, info);
+    free(info);
+}
+
+static const hs_expr_ext NO_EXT_PARAM = { 0, 0, 0, 0 };
+
 static const expected_info ei_test[] = {
-    {"abc", 3, 3, 0, 0, 0},
-    {"abc.*def", 6, UINT_MAX, 0, 0, 0},
-    {"abc|defghi", 3, 6, 0, 0, 0},
-    {"abc(def)?", 3, 6, 0, 0, 0},
-    {"abc(def){0,3}", 3, 12, 0, 0, 0},
-    {"abc(def){1,4}", 6, 15, 0, 0, 0},
-    {"", 0, 0, 0, 0, 0},
-    {"^", 0, 0, 0, 0, 0},
-    {"^\\b", 0, 0, 1, 0, 0},
-    {"\\b$", 0, 0, 1, 1, 1},
-    {"(?m)\\b$", 0, 0, 1, 1, 0},
-    {"\\A", 0, 0, 0, 0, 0},
-    {"\\z", 0, 0, 0, 1, 1},
-    {"\\Z", 0, 0, 1, 1, 1},
-    {"$", 0, 0, 1, 1, 1},
-    {"(?m)$", 0, 0, 1, 1, 0},
-    {"^foo", 3, 3, 0, 0, 0},
-    {"^foo.*bar", 6, UINT_MAX, 0, 0, 0},
-    {"^foo.*bar?", 5, UINT_MAX, 0, 0, 0},
-    {"^foo.*bar$", 6, UINT_MAX, 1, 1, 1},
-    {"^foobar$", 6, 6, 1, 1, 1},
-    {"foobar$", 6, 6, 1, 1, 1},
-    {"^.*foo", 3, UINT_MAX, 0, 0, 0},
-    {"foo\\b", 3, 3, 1, 1, 0},
-    {"foo.{1,13}bar", 7, 19, 0, 0, 0},
-    {"foo.{10,}bar", 16, UINT_MAX, 0, 0, 0},
-    {"foo.{0,10}bar", 6, 16, 0, 0, 0},
-    {"foo.{,10}bar", 12, 12, 0, 0, 0},
-    {"foo.{10}bar", 16, 16, 0, 0, 0},
-    {"(^|\n)foo", 3, 4, 0, 0, 0},
-    {"(^\n|)foo", 3, 4, 0, 0, 0},
-    {"(?m)^foo", 3, 3, 0, 0, 0},
-    {"\\bfoo", 3, 3, 0, 0, 0},
-    {"^\\bfoo", 3, 3, 0, 0, 0},
-    {"(?m)^\\bfoo", 3, 3, 0, 0, 0},
-    {"\\Bfoo", 3, 3, 0, 0, 0},
-    {"(foo|bar\\z)", 3, 3, 0, 1, 0},
-    {"(foo|bar)\\z", 3, 3, 0, 1, 1},
+    {"abc", NO_EXT_PARAM, 3, 3, 0, 0, 0},
+    {"abc.*def", NO_EXT_PARAM, 6, UINT_MAX, 0, 0, 0},
+    {"abc|defghi", NO_EXT_PARAM, 3, 6, 0, 0, 0},
+    {"abc(def)?", NO_EXT_PARAM, 3, 6, 0, 0, 0},
+    {"abc(def){0,3}", NO_EXT_PARAM, 3, 12, 0, 0, 0},
+    {"abc(def){1,4}", NO_EXT_PARAM, 6, 15, 0, 0, 0},
+    {"", NO_EXT_PARAM, 0, 0, 0, 0, 0},
+    {"^", NO_EXT_PARAM, 0, 0, 0, 0, 0},
+    {"^\\b", NO_EXT_PARAM, 0, 0, 1, 0, 0},
+    {"\\b$", NO_EXT_PARAM, 0, 0, 1, 1, 1},
+    {"(?m)\\b$", NO_EXT_PARAM, 0, 0, 1, 1, 0},
+    {"\\A", NO_EXT_PARAM, 0, 0, 0, 0, 0},
+    {"\\z", NO_EXT_PARAM, 0, 0, 0, 1, 1},
+    {"\\Z", NO_EXT_PARAM, 0, 0, 1, 1, 1},
+    {"$", NO_EXT_PARAM, 0, 0, 1, 1, 1},
+    {"(?m)$", NO_EXT_PARAM, 0, 0, 1, 1, 0},
+    {"^foo", NO_EXT_PARAM, 3, 3, 0, 0, 0},
+    {"^foo.*bar", NO_EXT_PARAM, 6, UINT_MAX, 0, 0, 0},
+    {"^foo.*bar?", NO_EXT_PARAM, 5, UINT_MAX, 0, 0, 0},
+    {"^foo.*bar$", NO_EXT_PARAM, 6, UINT_MAX, 1, 1, 1},
+    {"^foobar$", NO_EXT_PARAM, 6, 6, 1, 1, 1},
+    {"foobar$", NO_EXT_PARAM, 6, 6, 1, 1, 1},
+    {"^.*foo", NO_EXT_PARAM, 3, UINT_MAX, 0, 0, 0},
+    {"foo\\b", NO_EXT_PARAM, 3, 3, 1, 1, 0},
+    {"foo.{1,13}bar", NO_EXT_PARAM, 7, 19, 0, 0, 0},
+    {"foo.{10,}bar", NO_EXT_PARAM, 16, UINT_MAX, 0, 0, 0},
+    {"foo.{0,10}bar", NO_EXT_PARAM, 6, 16, 0, 0, 0},
+    {"foo.{,10}bar", NO_EXT_PARAM, 12, 12, 0, 0, 0},
+    {"foo.{10}bar", NO_EXT_PARAM, 16, 16, 0, 0, 0},
+    {"(^|\n)foo", NO_EXT_PARAM, 3, 4, 0, 0, 0},
+    {"(^\n|)foo", NO_EXT_PARAM, 3, 4, 0, 0, 0},
+    {"(?m)^foo", NO_EXT_PARAM, 3, 3, 0, 0, 0},
+    {"\\bfoo", NO_EXT_PARAM, 3, 3, 0, 0, 0},
+    {"^\\bfoo", NO_EXT_PARAM, 3, 3, 0, 0, 0},
+    {"(?m)^\\bfoo", NO_EXT_PARAM, 3, 3, 0, 0, 0},
+    {"\\Bfoo", NO_EXT_PARAM, 3, 3, 0, 0, 0},
+    {"(foo|bar\\z)", NO_EXT_PARAM, 3, 3, 0, 1, 0},
+    {"(foo|bar)\\z", NO_EXT_PARAM, 3, 3, 0, 1, 1},
+
+    // Some cases with extended parameters.
+    {"^abc.*def", {HS_EXT_FLAG_MAX_OFFSET, 0, 10, 0}, 6, 10, 0, 0, 0},
+    {"abc.*def", {HS_EXT_FLAG_MAX_OFFSET, 0, 10, 0}, 6, 10, 0, 0, 0},
+    {"abc.*def", {HS_EXT_FLAG_MIN_LENGTH, 0, 0, 100}, 100, UINT_MAX, 0, 0, 0},
+    {"abc.*def", {HS_EXT_FLAG_MIN_LENGTH, 0, 0, 5}, 6, UINT_MAX, 0, 0, 0},
 };
 
 INSTANTIATE_TEST_CASE_P(ExprInfo, ExprInfop, ValuesIn(ei_test));
diff --git a/unit/hyperscan/extparam.cpp b/unit/hyperscan/extparam.cpp
index ba64132e..e9919be6 100644
--- a/unit/hyperscan/extparam.cpp
+++ b/unit/hyperscan/extparam.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -70,7 +70,8 @@ TEST(ExtParam, LargeMinOffset) {
     ASSERT_EQ(1U, c.matches.size());
     ASSERT_EQ(MatchRecord(100000, 0), c.matches[0]);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -116,7 +117,8 @@ TEST(ExtParam, LargeExactOffset) {
     ASSERT_EQ(HS_SUCCESS, err);
     ASSERT_EQ(0U, c.matches.size());
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -153,6 +155,7 @@ TEST(ExtParam, LargeMinLength) {
     ASSERT_EQ(1U, c.matches.size());
     ASSERT_EQ(MatchRecord(110000, 0), c.matches[0]);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
diff --git a/unit/hyperscan/identical.cpp b/unit/hyperscan/identical.cpp
index a4f1fe44..cbeb0242 100644
--- a/unit/hyperscan/identical.cpp
+++ b/unit/hyperscan/identical.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -64,7 +64,8 @@ TEST_P(IdenticalTest, Block) {
                   record_cb, &cb);
     ASSERT_EQ(HS_SUCCESS, err);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 
     ASSERT_EQ(patterns.size(), cb.matches.size());
@@ -111,7 +112,8 @@ TEST_P(IdenticalTest, Stream) {
     err = hs_close_stream(stream, scratch, record_cb, &cb);
     ASSERT_EQ(HS_SUCCESS, err);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 
     ASSERT_EQ(patterns.size(), cb.matches.size());
@@ -151,7 +153,8 @@ TEST_P(IdenticalTest, Vectored) {
     err = hs_scan_vector(db, data, datalen, 1, 0, scratch, record_cb, &cb);
     ASSERT_EQ(HS_SUCCESS, err);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 
     ASSERT_EQ(patterns.size(), cb.matches.size());
diff --git a/unit/hyperscan/multi.cpp b/unit/hyperscan/multi.cpp
index db8d5715..d43ce327 100644
--- a/unit/hyperscan/multi.cpp
+++ b/unit/hyperscan/multi.cpp
@@ -67,7 +67,8 @@ TEST(MMAdaptor, norm_cont1) { // UE-901
     ASSERT_EQ(MatchRecord(12, 31), c.matches[2]);
 
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
 
 TEST(MMAdaptor, norm_cont2) {
@@ -99,7 +100,8 @@ TEST(MMAdaptor, norm_cont2) {
     ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(28, 31)));
 
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
 
 TEST(MMAdaptor, norm_halt1) {
@@ -129,7 +131,8 @@ TEST(MMAdaptor, norm_halt1) {
     ASSERT_EQ(MatchRecord(4, 30), c.matches[0]);
 
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
 
 TEST(MMAdaptor, norm_halt2) { // UE-901
@@ -159,7 +162,8 @@ TEST(MMAdaptor, norm_halt2) { // UE-901
     ASSERT_EQ(MatchRecord(20, 30), c.matches[0]);
 
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
 
 TEST(MMAdaptor, high_cont1) { // UE-901
@@ -190,7 +194,8 @@ TEST(MMAdaptor, high_cont1) { // UE-901
     ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(12, 31)));
 
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
 
 TEST(MMAdaptor, high_cont2) {
@@ -221,7 +226,8 @@ TEST(MMAdaptor, high_cont2) {
     ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(28, 31)));
 
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
 
 TEST(MMAdaptor, high_halt1) {
@@ -251,7 +257,8 @@ TEST(MMAdaptor, high_halt1) {
     ASSERT_EQ(MatchRecord(4, 30), c.matches[0]);
 
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
 
 TEST(MMAdaptor, high_halt2) {
@@ -282,7 +289,8 @@ TEST(MMAdaptor, high_halt2) {
                 || MatchRecord(28, 31) == c.matches[0]);
 
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
 
 TEST(MPV, UE_2395) {
@@ -322,5 +330,6 @@ TEST(MPV, UE_2395) {
     ASSERT_EQ(300, seen);
 
     hs_free_database(db);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
 }
diff --git a/unit/hyperscan/order.cpp b/unit/hyperscan/order.cpp
index 4c44b4bb..b052e4b4 100644
--- a/unit/hyperscan/order.cpp
+++ b/unit/hyperscan/order.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -91,7 +91,8 @@ TEST(order, ordering1) {
     EXPECT_EQ(5U, countMatchesById(c.matches, 4));
     EXPECT_EQ(5U, countMatchesById(c.matches, 5));
     ASSERT_TRUE(matchesOrdered(c.matches));
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -122,7 +123,8 @@ TEST(order, ordering2) {
     EXPECT_EQ(5U, countMatchesById(c.matches, 4));
     EXPECT_EQ(5U, countMatchesById(c.matches, 5));
     ASSERT_TRUE(matchesOrdered(c.matches));
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -152,7 +154,8 @@ TEST(order, ordering3) {
     EXPECT_EQ(5U, countMatchesById(c.matches, 4));
     EXPECT_EQ(0U, countMatchesById(c.matches, 5));
     ASSERT_TRUE(matchesOrdered(c.matches));
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -182,7 +185,8 @@ TEST(order, ordering4) {
     EXPECT_EQ(0U, countMatchesById(c.matches, 4));
     EXPECT_EQ(0U, countMatchesById(c.matches, 5));
     ASSERT_TRUE(matchesOrdered(c.matches));
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -225,7 +229,8 @@ TEST(order, ordering5) {
         c.matches.clear();
         hs_close_stream(stream, scratch, record_cb, (void *)&c);
     }
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -267,7 +272,8 @@ TEST(order, ordering6) {
         c.matches.clear();
         hs_close_stream(stream, scratch, record_cb, (void *)&c);
     }
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -308,7 +314,8 @@ TEST(order, ordering7) {
         c.matches.clear();
         hs_close_stream(stream, scratch, record_cb, (void *)&c);
     }
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -349,7 +356,8 @@ TEST(order, ordering8) {
         c.matches.clear();
         hs_close_stream(stream, scratch, record_cb, (void *)&c);
     }
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
diff --git a/unit/hyperscan/scratch_in_use.cpp b/unit/hyperscan/scratch_in_use.cpp
new file mode 100644
index 00000000..a9e8c800
--- /dev/null
+++ b/unit/hyperscan/scratch_in_use.cpp
@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) 2016, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include "test_util.h"
+
+#include "hs.h"
+#include "gtest/gtest.h"
+
+#include <memory>
+
+using namespace std;
+
+struct RescanContext {
+    RescanContext(const hs_database_t *db_in, hs_scratch_t *scratch_in)
+        : db(db_in), scratch(scratch_in) {}
+    const hs_database_t *db;
+    hs_scratch_t *scratch;
+    size_t matches = 0;
+};
+
+struct HyperscanDatabaseDeleter {
+    void operator()(hs_database_t *db) const {
+        hs_error_t err = hs_free_database(db);
+        EXPECT_EQ(HS_SUCCESS, err);
+    }
+};
+
+unique_ptr<hs_database_t, HyperscanDatabaseDeleter>
+makeDatabase(const char *expression, unsigned int flags, unsigned int mode) {
+    hs_database_t *db = nullptr;
+    hs_compile_error_t *compile_err = nullptr;
+    hs_error_t err = hs_compile(expression, flags, mode, nullptr, &db,
+                                &compile_err);
+    EXPECT_EQ(HS_SUCCESS, err);
+
+    return unique_ptr<hs_database_t, HyperscanDatabaseDeleter>(db);
+}
+
+// Generic block mode test that uses the given scan callback.
+static
+void runBlockTest(match_event_handler cb_func) {
+    auto db = makeDatabase("foo.*bar", 0, HS_MODE_BLOCK);
+    ASSERT_NE(nullptr, db.get());
+
+    hs_scratch_t *scratch = nullptr;
+    hs_error_t err = hs_alloc_scratch(db.get(), &scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
+    ASSERT_TRUE(scratch != nullptr);
+
+    RescanContext rc(db.get(), scratch);
+    const string data = "___foo___bar_";
+
+    err = hs_scan(db.get(), data.c_str(), data.length(), 0, scratch,
+                  cb_func, &rc);
+    ASSERT_EQ(HS_SUCCESS, err);
+    ASSERT_EQ(1, rc.matches);
+
+    // teardown
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
+}
+
+// Generic streaming mode test that uses the given scan callback.
+static
+void runStreamingTest(match_event_handler cb_func) {
+    auto db = makeDatabase("foo.*bar", 0, HS_MODE_STREAM);
+    ASSERT_NE(nullptr, db.get());
+
+    hs_scratch_t *scratch = nullptr;
+    hs_error_t err = hs_alloc_scratch(db.get(), &scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
+    ASSERT_TRUE(scratch != nullptr);
+
+    hs_stream_t *stream = nullptr;
+    err = hs_open_stream(db.get(), 0, &stream);
+    ASSERT_EQ(HS_SUCCESS, err);
+    ASSERT_TRUE(stream != nullptr);
+
+    RescanContext rc(db.get(), scratch);
+    const string data = "___foo___bar_";
+
+    err = hs_scan_stream(stream, data.c_str(), data.length(), 0, scratch,
+                         cb_func, &rc);
+    ASSERT_EQ(HS_SUCCESS, err);
+    ASSERT_EQ(1, rc.matches);
+
+    // teardown
+    hs_close_stream(stream, scratch, nullptr, nullptr);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
+}
+
+// Generic vectored mode test that uses the given scan callback.
+static
+void runVectoredTest(match_event_handler cb_func) {
+    auto db = makeDatabase("foo.*bar", 0, HS_MODE_VECTORED);
+    ASSERT_NE(nullptr, db.get());
+
+    hs_scratch_t *scratch = nullptr;
+    hs_error_t err = hs_alloc_scratch(db.get(), &scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
+    ASSERT_TRUE(scratch != nullptr);
+
+    RescanContext rc(db.get(), scratch);
+    const string data1 = "___foo_";
+    const string data2 = "bar_";
+
+    const char *vec[] = {data1.c_str(), data2.c_str()};
+    const unsigned int len[] = {unsigned(data1.length()),
+                                unsigned(data2.length())};
+
+    err = hs_scan_vector(db.get(), vec, len, 2, 0, scratch, cb_func, &rc);
+    ASSERT_EQ(HS_SUCCESS, err);
+    ASSERT_EQ(1, rc.matches);
+
+    // teardown
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
+}
+
+static
+int rescan_block_cb(unsigned, unsigned long long, unsigned long long, unsigned,
+                    void *ctx) {
+    RescanContext *rctx = (RescanContext *)ctx;
+    rctx->matches++;
+
+    const string data = "___foo___bar_";
+
+    hs_error_t err = hs_scan(rctx->db, data.c_str(), data.length(), 0,
+                             rctx->scratch, dummy_cb, nullptr);
+    EXPECT_EQ(HS_SCRATCH_IN_USE, err);
+    return 0;
+}
+
+
+// Attempt to use in-use scratch inside block mode callback.
+TEST(ScratchInUse, Block) {
+    runBlockTest(rescan_block_cb);
+}
+
+static
+int rescan_stream_cb(unsigned, unsigned long long, unsigned long long, unsigned,
+                     void *ctx) {
+    RescanContext *rctx = (RescanContext *)ctx;
+    rctx->matches++;
+
+    const string data = "___foo___bar_";
+
+    hs_stream_t *stream = nullptr;
+    hs_error_t err = hs_open_stream(rctx->db, 0, &stream);
+    EXPECT_EQ(HS_SUCCESS, err);
+    EXPECT_TRUE(stream != nullptr);
+    if (stream == nullptr) {
+        return 1;
+    }
+
+    err = hs_scan_stream(stream, data.c_str(), data.length(), 0,
+                         rctx->scratch, dummy_cb, nullptr);
+    EXPECT_EQ(HS_SCRATCH_IN_USE, err);
+
+    hs_close_stream(stream, nullptr, nullptr, nullptr);
+    return 0;
+}
+
+// Attempt to use in-use scratch inside streaming mode callback.
+TEST(ScratchInUse, Streaming) {
+    runStreamingTest(rescan_stream_cb);
+}
+
+static
+int rescan_vector_cb(unsigned, unsigned long long, unsigned long long, unsigned,
+                    void *ctx) {
+    RescanContext *rctx = (RescanContext *)ctx;
+    rctx->matches++;
+
+    const string data1 = "___foo_";
+    const string data2 = "bar_";
+
+    const char *vec[] = {data1.c_str(), data2.c_str()};
+    const unsigned int len[] = {unsigned(data1.length()),
+                                unsigned(data2.length())};
+
+    hs_error_t err = hs_scan_vector(rctx->db, vec, len, 2, 0, rctx->scratch,
+                                    dummy_cb, nullptr);
+    EXPECT_EQ(HS_SCRATCH_IN_USE, err);
+    return 0;
+}
+
+// Attempt to use in-use scratch inside vectored mode callback.
+TEST(ScratchInUse, Vectored) {
+    runVectoredTest(rescan_vector_cb);
+}
+
+static
+int rescan_realloc_cb(unsigned, unsigned long long, unsigned long long,
+                      unsigned, void *ctx) {
+    RescanContext *rctx = (RescanContext *)ctx;
+    rctx->matches++;
+
+    auto db = makeDatabase("another db", 0, HS_MODE_BLOCK);
+    hs_error_t err = hs_alloc_scratch(db.get(), &rctx->scratch);
+    EXPECT_EQ(HS_SCRATCH_IN_USE, err);
+    return 0;
+}
+
+// Attempt to use hs_alloc_scratch on in-use scratch inside callback (block
+// scan).
+TEST(ScratchInUse, ReallocScratchBlock) {
+    runBlockTest(rescan_realloc_cb);
+}
+
+// Attempt to use hs_alloc_scratch on in-use scratch inside callback (streaming
+// scan).
+TEST(ScratchInUse, ReallocScratchStreaming) {
+    runStreamingTest(rescan_realloc_cb);
+}
+
+// Attempt to use hs_alloc_scratch on in-use scratch inside callback (vectored
+// scan).
+TEST(ScratchInUse, ReallocScratchVector) {
+    runVectoredTest(rescan_realloc_cb);
+}
+
+static
+int rescan_free_cb(unsigned, unsigned long long, unsigned long long,
+                      unsigned, void *ctx) {
+    RescanContext *rctx = (RescanContext *)ctx;
+    rctx->matches++;
+
+    hs_error_t err = hs_free_scratch(rctx->scratch);
+    EXPECT_EQ(HS_SCRATCH_IN_USE, err);
+    return 0;
+}
+
+// Attempt to use hs_free_scratch on in-use scratch inside callback (block
+// scan).
+TEST(ScratchInUse, FreeScratchBlock) {
+    runBlockTest(rescan_free_cb);
+}
+
+// Attempt to use hs_free_scratch on in-use scratch inside callback (streaming
+// scan).
+TEST(ScratchInUse, FreeScratchStreaming) {
+    runStreamingTest(rescan_free_cb);
+}
+
+// Attempt to use hs_free_scratch on in-use scratch inside callback (vectored
+// scan).
+TEST(ScratchInUse, FreeScratchVector) {
+    runVectoredTest(rescan_free_cb);
+}
diff --git a/unit/hyperscan/scratch_op.cpp b/unit/hyperscan/scratch_op.cpp
index b3d3ddd9..338a0427 100644
--- a/unit/hyperscan/scratch_op.cpp
+++ b/unit/hyperscan/scratch_op.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -75,7 +75,8 @@ TEST(scratch, testAlloc) {
     ASSERT_EQ(HS_SUCCESS, err);
     ASSERT_EQ(last_alloc_size, curr_size);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
     hs_set_allocator(nullptr, nullptr);
 }
@@ -114,7 +115,8 @@ TEST(scratch, testScratchAlloc) {
     ASSERT_EQ(allocated_count, curr_size);
     ASSERT_EQ(allocated_count_b, old_b);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
     hs_set_allocator(nullptr, nullptr);
 
@@ -185,7 +187,8 @@ TEST(scratch, testScratchRealloc) {
     ASSERT_EQ(HS_SUCCESS, err);
     ASSERT_EQ(last_alloc_size, curr_size);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
     hs_free_database(db2);
     hs_set_scratch_allocator(nullptr, nullptr);
@@ -217,7 +220,8 @@ TEST(scratch, tooSmallForDatabase) {
     err = hs_scan(db2, "somedata", 8, 0, scratch, dummy_cb, nullptr);
     ASSERT_EQ(HS_SUCCESS, err);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db2);
 }
 
@@ -252,7 +256,8 @@ TEST(scratch, tooSmallForDatabase2) {
     err = hs_close_stream(stream, scratch, nullptr, nullptr);
     ASSERT_EQ(HS_SUCCESS, err);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db2);
 }
 
diff --git a/unit/hyperscan/single.cpp b/unit/hyperscan/single.cpp
index 4bb0f204..029d223a 100644
--- a/unit/hyperscan/single.cpp
+++ b/unit/hyperscan/single.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -157,7 +157,8 @@ protected:
         }
 
         // teardown
-        hs_free_scratch(scratch);
+        err = hs_free_scratch(scratch);
+        ASSERT_EQ(HS_SUCCESS, err);
     }
 
     virtual void zeroLengthScan() {
@@ -195,7 +196,8 @@ protected:
         }
 
         // teardown
-        hs_free_scratch(scratch);
+        err = hs_free_scratch(scratch);
+        ASSERT_EQ(HS_SUCCESS, err);
     }
 
     // Can we allocate and clone scratch
@@ -212,8 +214,10 @@ protected:
         ASSERT_EQ(HS_SUCCESS, err);
         EXPECT_TRUE(cloned != nullptr);
 
-        hs_free_scratch(scratch);
-        hs_free_scratch(cloned);
+        err = hs_free_scratch(scratch);
+        EXPECT_EQ(HS_SUCCESS, err);
+        err = hs_free_scratch(cloned);
+        EXPECT_EQ(HS_SUCCESS, err);
     }
 
     // Can we scan with the database (ignoring the matches, and using
@@ -412,7 +416,8 @@ protected:
         // that platform produces HS_SUCCESS.
         if (err == HS_SUCCESS) {
             // host platform.
-            hs_free_scratch(scratch);
+            err = hs_free_scratch(scratch);
+            ASSERT_EQ(HS_SUCCESS, err);
         } else {
             ASSERT_EQ(HS_DB_PLATFORM_ERROR, err);
             ASSERT_TRUE(!scratch);
@@ -519,7 +524,8 @@ TEST_P(HyperscanTestMatchTerminate, MoreThanOne) {
     ASSERT_EQ(HS_SUCCESS, err) << "hs_scan didn't return HS_SCAN_TERMINATED";
     ASSERT_LT(1, count) << "Number of matches returned was not greater than 1.";
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -538,7 +544,8 @@ TEST_P(HyperscanTestMatchTerminate, Block) {
         << "hs_scan didn't return HS_SCAN_TERMINATED";
     ASSERT_EQ(1, count) << "Number of matches returned was not 1.";
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -563,7 +570,8 @@ TEST_P(HyperscanTestMatchTerminate, StreamWhole) {
     err = hs_close_stream(stream, scratch, terminateHandler, &count);
     ASSERT_EQ(1, count) << "Number of matches returned was not 1.";
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -591,7 +599,8 @@ TEST_P(HyperscanTestMatchTerminate, StreamByteByByte) {
     err = hs_close_stream(stream, scratch, terminateHandler, &count);
     ASSERT_EQ(1, count) << "Number of matches returned was not 1.";
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
diff --git a/unit/hyperscan/som.cpp b/unit/hyperscan/som.cpp
index cc1077d2..bf2d7c42 100644
--- a/unit/hyperscan/som.cpp
+++ b/unit/hyperscan/som.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -132,7 +132,8 @@ TEST_P(SomTest, PastHorizon) {
     ASSERT_EQ(HS_SUCCESS, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -190,7 +191,8 @@ TEST_P(SomTest, NearHorizon) {
     ASSERT_EQ(HS_SUCCESS, err);
 
     // teardown
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
diff --git a/unit/hyperscan/stream_op.cpp b/unit/hyperscan/stream_op.cpp
index a78e08a1..48cb6b8d 100644
--- a/unit/hyperscan/stream_op.cpp
+++ b/unit/hyperscan/stream_op.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -82,7 +82,8 @@ TEST(StreamUtil, reset1) {
     ASSERT_EQ(MatchRecord(1009, 0), c2.matches[0]);
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -122,7 +123,8 @@ TEST(StreamUtil, reset2) {
     ASSERT_EQ(MatchRecord(9, 0), c2.matches[0]);
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -150,7 +152,8 @@ TEST(StreamUtil, reset_matches) {
     ASSERT_EQ(MatchRecord(9, 0), c.matches[0]);
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -198,7 +201,8 @@ TEST(StreamUtil, copy1) {
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_close_stream(stream2, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -241,7 +245,8 @@ TEST(StreamUtil, copy2) {
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_close_stream(stream2, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -284,7 +289,8 @@ TEST(StreamUtil, copy_reset1) {
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_close_stream(stream2, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -328,7 +334,8 @@ TEST(StreamUtil, copy_reset2) {
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_close_stream(stream2, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -380,7 +387,8 @@ TEST(StreamUtil, copy_reset3) {
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_close_stream(stream2, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -427,7 +435,8 @@ TEST(StreamUtil, copy_reset4) {
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_close_stream(stream2, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -483,7 +492,8 @@ TEST(StreamUtil, copy_reset5) {
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_close_stream(stream2, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -519,7 +529,8 @@ TEST(StreamUtil, copy_reset_matches) {
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_close_stream(stream2, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -554,7 +565,8 @@ TEST(StreamUtil, size) {
     hs_set_allocator(nullptr, nullptr);
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
 }
 
@@ -629,7 +641,8 @@ TEST(StreamUtil, Alloc) {
 
     hs_close_stream(stream, scratch, record_cb, (void *)&c);
     ASSERT_EQ(alloc_called, 0);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
     hs_free_compile_error(compile_err);
     hs_set_allocator(nullptr, nullptr);
@@ -670,7 +683,8 @@ TEST(StreamUtil, MoreAlloc) {
 
     hs_close_stream(stream, scratch, nullptr, nullptr);
     ASSERT_EQ(alloc_called, 2);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     ASSERT_EQ(alloc_called, 1);
     hs_free_database(db);
     ASSERT_EQ(alloc_called, 0);
@@ -702,7 +716,8 @@ TEST(StreamUtil, BadStreamAlloc) {
     err = hs_open_stream(db, 0, &stream);
     ASSERT_NE(HS_SUCCESS, err);
 
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
     hs_free_compile_error(compile_err);
     hs_set_stream_allocator(nullptr, nullptr);
@@ -758,7 +773,8 @@ TEST(StreamUtil, StreamAllocUsage) {
     hs_close_stream(stream, scratch, nullptr, nullptr);
     hs_close_stream(stream2, scratch, nullptr, nullptr);
     hs_close_stream(stream3, scratch, nullptr, nullptr);
-    hs_free_scratch(scratch);
+    err = hs_free_scratch(scratch);
+    ASSERT_EQ(HS_SUCCESS, err);
     hs_free_database(db);
     hs_free_compile_error(compile_err);
     hs_set_allocator(nullptr, nullptr);
diff --git a/unit/hyperscan/test_util.h b/unit/hyperscan/test_util.h
index 1ce0c182..fad6137c 100644
--- a/unit/hyperscan/test_util.h
+++ b/unit/hyperscan/test_util.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -29,7 +29,9 @@
 #ifndef TEST_UTIL_H
 #define TEST_UTIL_H
 
+#include <cstring>
 #include <iosfwd>
+#include <string>
 #include <vector>
 
 #include "hs.h"
diff --git a/unit/internal/fdr.cpp b/unit/internal/fdr.cpp
index 3aada867..c66ab4c5 100644
--- a/unit/internal/fdr.cpp
+++ b/unit/internal/fdr.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -59,8 +59,8 @@ using namespace ue2;
 #define CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint)                                 \
     {                                                                          \
         auto descr = getTeddyDescription(hint);                                \
-        if (descr && fdr != nullptr) {                                         \
-            return;                                                            \
+        if (descr && fdr == nullptr) {                                         \
+            return; /* cannot build Teddy for this set of literals */          \
         } else {                                                               \
             ASSERT_TRUE(fdr != nullptr);                                       \
         }                                                                      \
@@ -133,23 +133,25 @@ hwlmcb_rv_t decentCallbackT(size_t start, size_t end, u32 id, void *ctxt) {
 
 } // namespace
 
-static vector<u32> getValidFdrEngines() {
+static
+vector<u32> getValidFdrEngines() {
+    const auto target = get_current_target();
+
     vector<u32> ret;
-    vector<FDREngineDescription> des;
-    getFdrDescriptions(&des);
-    for (vector<FDREngineDescription>::const_iterator it = des.begin();
-         it != des.end(); ++it) {
-        if (it->isValidOnTarget(get_current_target())) {
-            ret.push_back(it->getID());
+
+    vector<FDREngineDescription> fdr_descriptions;
+    getFdrDescriptions(&fdr_descriptions);
+    for (const FDREngineDescription &d : fdr_descriptions) {
+        if (d.isValidOnTarget(target)) {
+            ret.push_back(d.getID());
         }
     }
 
-    vector<TeddyEngineDescription> tDes;
-    getTeddyDescriptions(&tDes);
-    for (vector<TeddyEngineDescription>::const_iterator it = tDes.begin();
-         it != tDes.end(); ++it) {
-        if (it->isValidOnTarget(get_current_target())) {
-            ret.push_back(it->getID());
+    vector<TeddyEngineDescription> teddy_descriptions;
+    getTeddyDescriptions(&teddy_descriptions);
+    for (const TeddyEngineDescription &d : teddy_descriptions) {
+        if (d.isValidOnTarget(target)) {
+            ret.push_back(d.getID());
         }
     }
 
@@ -328,14 +330,32 @@ TEST_P(FDRp, NoRepeat3) {
     EXPECT_EQ(match(31, 32, 0), matches[0]);
 }
 
+/**
+ * \brief Helper function wrapping the FDR streaming call that ensures it is
+ * always safe to read 16 bytes before the end of the history buffer.
+ */
+static
+hwlm_error_t safeExecStreaming(const FDR *fdr, const u8 *hbuf, size_t hlen,
+                               const u8 *buf, size_t len, size_t start,
+                               HWLMCallback cb, void *ctxt, hwlm_group_t groups,
+                               u8 *stream_state) {
+    array<u8, 16> wrapped_history = {{'0', '1', '2', '3', '4', '5', '6', '7',
+                                      '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}};
+    if (hlen < 16) {
+        u8 *new_hbuf = wrapped_history.data() + 16 - hlen;
+        memcpy(new_hbuf, hbuf, hlen);
+        hbuf = new_hbuf;
+    }
+    return fdrExecStreaming(fdr, hbuf, hlen, buf, len, start, cb, ctxt, groups,
+                            stream_state);
+}
 
 TEST_P(FDRp, SmallStreaming) {
     const u32 hint = GetParam();
     SCOPED_TRACE(hint);
-    vector<hwlmLiteral> lits;
 
-    lits.push_back(hwlmLiteral("a", 1, 1));
-    lits.push_back(hwlmLiteral("aardvark", 0, 10));
+    vector<hwlmLiteral> lits = {hwlmLiteral("a", 1, 1),
+                                hwlmLiteral("aardvark", 0, 10)};
 
     auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey());
     CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
@@ -345,8 +365,8 @@ TEST_P(FDRp, SmallStreaming) {
     expected.push_back(match(1, 1, 1));
     expected.push_back(match(2, 2, 1));
 
-    fdrExecStreaming(fdr.get(), (const u8 *)"", 0, (const u8 *)"aaar", 4, 0,
-                     decentCallback, &matches, HWLM_ALL_GROUPS, nullptr);
+    safeExecStreaming(fdr.get(), (const u8 *)"", 0, (const u8 *)"aaar", 4, 0,
+                      decentCallback, &matches, HWLM_ALL_GROUPS, nullptr);
     for (u32 i = 0; i < MIN(expected.size(), matches.size()); i++) {
         EXPECT_EQ(expected[i], matches[i]);
     }
@@ -357,8 +377,8 @@ TEST_P(FDRp, SmallStreaming) {
     expected.push_back(match(6, 6, 1));
     expected.push_back(match(1, 8, 10));
 
-    fdrExecStreaming(fdr.get(), (const u8 *)"aaar", 4, (const u8 *)"dvark", 5,
-                     0, decentCallback, &matches, HWLM_ALL_GROUPS, nullptr);
+    safeExecStreaming(fdr.get(), (const u8 *)"aaar", 4, (const u8 *)"dvark", 5,
+                      0, decentCallback, &matches, HWLM_ALL_GROUPS, nullptr);
 
     for (u32 i = 0; i < MIN(expected.size(), matches.size()); i++) {
         EXPECT_EQ(expected[i], matches[i] + 4);
@@ -369,11 +389,10 @@ TEST_P(FDRp, SmallStreaming) {
 TEST_P(FDRp, SmallStreaming2) {
     const u32 hint = GetParam();
     SCOPED_TRACE(hint);
-    vector<hwlmLiteral> lits;
 
-    lits.push_back(hwlmLiteral("a",1,1));
-    lits.push_back(hwlmLiteral("kk",1,2));
-    lits.push_back(hwlmLiteral("aardvark", 0,10));
+    vector<hwlmLiteral> lits = {hwlmLiteral("a", 1, 1),
+                                hwlmLiteral("kk", 1, 2),
+                                hwlmLiteral("aardvark", 0, 10)};
 
     auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey());
     CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
@@ -386,9 +405,9 @@ TEST_P(FDRp, SmallStreaming2) {
     expected.push_back(match(13,14,2));
     expected.push_back(match(14,15,2));
 
-    fdrExecStreaming(fdr.get(), (const u8 *)"foobar", 6,
-                     (const u8 *)"aardvarkkk", 10, 0, decentCallback, &matches,
-                     HWLM_ALL_GROUPS, nullptr);
+    safeExecStreaming(fdr.get(), (const u8 *)"foobar", 6,
+                      (const u8 *)"aardvarkkk", 10, 0, decentCallback, &matches,
+                      HWLM_ALL_GROUPS, nullptr);
 
     for (u32 i = 0; i < MIN(expected.size(), matches.size()); i++) {
         EXPECT_EQ(expected[i], matches[i] + 6);
@@ -519,9 +538,9 @@ TEST_P(FDRp, Stream1) {
     // check matches
     vector<match> matches;
 
-    fdrStatus = fdrExecStreaming(fdr.get(), (const u8 *)data1, data_len1,
-                                 (const u8 *)data2, data_len2, 0,
-                                 decentCallback, &matches, HWLM_ALL_GROUPS, nullptr);
+    fdrStatus = safeExecStreaming(
+        fdr.get(), (const u8 *)data1, data_len1, (const u8 *)data2, data_len2,
+        0, decentCallback, &matches, HWLM_ALL_GROUPS, nullptr);
     ASSERT_EQ(0, fdrStatus);
 
     ASSERT_EQ(4U, matches.size());
@@ -764,9 +783,9 @@ TEST(FDR, FDRTermS) {
     // check matches
     vector<match> matches;
 
-    fdrStatus = fdrExecStreaming(fdr.get(), (const u8 *)data1, data_len1,
-                                 (const u8 *)data2, data_len2, 0,
-                                 decentCallbackT, &matches, HWLM_ALL_GROUPS, nullptr);
+    fdrStatus = safeExecStreaming(
+        fdr.get(), (const u8 *)data1, data_len1, (const u8 *)data2, data_len2,
+        0, decentCallbackT, &matches, HWLM_ALL_GROUPS, nullptr);
     ASSERT_EQ(HWLM_TERMINATED, fdrStatus);
 
     ASSERT_EQ(1U, matches.size());
diff --git a/unit/internal/fdr_flood.cpp b/unit/internal/fdr_flood.cpp
index bda8c624..68d8f632 100644
--- a/unit/internal/fdr_flood.cpp
+++ b/unit/internal/fdr_flood.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -403,8 +403,11 @@ TEST_P(FDRFloodp, WithMask) {
 TEST_P(FDRFloodp, StreamingMask) {
     const u32 hint = GetParam();
     SCOPED_TRACE(hint);
+    const size_t fake_history_size = 16;
+    const vector<u8> fake_history(fake_history_size, 0);
     const size_t dataSize = 1024;
     vector<u8> data(dataSize);
+    vector<u8> tempdata(dataSize + fake_history_size); // headroom
     u8 c = '\0';
 
     while (1) {
@@ -487,18 +490,28 @@ TEST_P(FDRFloodp, StreamingMask) {
 
         for (u32 streamChunk = 1; streamChunk <= 16; streamChunk *= 2) {
             matchesCounts.clear();
-            fdrStatus = fdrExecStreaming(fdr.get(), nullptr, 0, &data[0], streamChunk,
-                            0, countCallback, &matchesCounts, HWLM_ALL_GROUPS, nullptr);
+            const u8 *d = data.data();
+            // reference past the end of fake history to allow headroom
+            const u8 *fhist = fake_history.data() + fake_history_size;
+            fdrStatus = fdrExecStreaming(fdr.get(), fhist, 0, d, streamChunk, 0,
+                                         countCallback, &matchesCounts,
+                                         HWLM_ALL_GROUPS, nullptr);
             ASSERT_EQ(0, fdrStatus);
             for (u32 j = streamChunk; j < dataSize; j += streamChunk) {
-                if (j < 8) {
-                    fdrStatus = fdrExecStreaming(fdr.get(), &data[0], j,
-                            &data[0] + j, streamChunk, 0, countCallback,
-                            &matchesCounts, HWLM_ALL_GROUPS, nullptr);
+                if (j < 16) {
+                    /* allow 16 bytes headroom on read to avoid invalid
+                     * memory read during the FDR zone creation.*/
+                    memset(tempdata.data(), c, dataSize + fake_history_size);
+                    const u8 *tmp_d = tempdata.data() + fake_history_size;
+                    fdrStatus = fdrExecStreaming(fdr.get(), tmp_d, j, tmp_d + j,
+                                                 streamChunk, 0, countCallback,
+                                                 &matchesCounts,
+                                                 HWLM_ALL_GROUPS, nullptr);
                 } else {
-                    fdrStatus = fdrExecStreaming(fdr.get(), &data[0] + j - 8,
-                            8, &data[0] + j, streamChunk, 0, countCallback,
-                            &matchesCounts, HWLM_ALL_GROUPS, nullptr);
+                    fdrStatus = fdrExecStreaming(fdr.get(), d + j - 8, 8, d + j,
+                                                 streamChunk, 0, countCallback,
+                                                 &matchesCounts,
+                                                 HWLM_ALL_GROUPS, nullptr);
                 }
                 ASSERT_EQ(0, fdrStatus);
             }
diff --git a/unit/internal/fdr_loadval.cpp b/unit/internal/fdr_loadval.cpp
index ba5ae692..22fee770 100644
--- a/unit/internal/fdr_loadval.cpp
+++ b/unit/internal/fdr_loadval.cpp
@@ -39,55 +39,26 @@ using namespace ue2;
 // Normal (unaligned) load.
 template <typename T> T lv(const u8 *ptr, const u8 *lo, const u8 *hi);
 
-// Aligned load.
-template <typename T> T lv_a(const u8 *ptr, const u8 *lo, const u8 *hi);
-
-// Cautious forward load.
-template <typename T> T lv_cf(const u8 *ptr, const u8 *lo, const u8 *hi);
-
-// Cautious backward load.
-template <typename T> T lv_cb(const u8 *ptr, const u8 *lo, const u8 *hi);
-
 // Cautious everywhere load.
 template <typename T> T lv_ce(const u8 *ptr, const u8 *lo, const u8 *hi);
 
-// Special case: there is no specific _a "aligned load" func for u8. We proxy
-// that to the normal load.
-static u8 lv_u8_a(const u8 *ptr, const u8 *lo, const u8 *hi) {
-    return lv_u8(ptr, lo, hi);
-}
-
 #define BUILD_LOADVALS(vtype)                                                  \
     template <> vtype lv<vtype>(const u8 *ptr, const u8 *lo, const u8 *hi) {   \
         return lv_##vtype(ptr, lo, hi);                                        \
     }                                                                          \
-    template <> vtype lv_a<vtype>(const u8 *ptr, const u8 *lo, const u8 *hi) { \
-        return lv_##vtype##_a(ptr, lo, hi);                                    \
-    }                                                                          \
-    template <>                                                                \
-    vtype lv_cf<vtype>(const u8 *ptr, const u8 *lo, const u8 *hi) {            \
-        return lv_##vtype##_cf(ptr, lo, hi);                                   \
-    }                                                                          \
-    template <>                                                                \
-    vtype lv_cb<vtype>(const u8 *ptr, const u8 *lo, const u8 *hi) {            \
-        return lv_##vtype##_cb(ptr, lo, hi);                                   \
-    }                                                                          \
     template <>                                                                \
     vtype lv_ce<vtype>(const u8 *ptr, const u8 *lo, const u8 *hi) {            \
         return lv_##vtype##_ce(ptr, lo, hi);                                   \
     }
 
-BUILD_LOADVALS(u8)
 BUILD_LOADVALS(u16)
-BUILD_LOADVALS(u32)
 BUILD_LOADVALS(u64a)
-BUILD_LOADVALS(m128)
 
 template <typename T> class FDR_Loadval : public testing::Test {
     // empty
 };
 
-typedef ::testing::Types<u8, u16, u32, u64a, m128> LoadvalTypes;
+typedef ::testing::Types<u16, u64a> LoadvalTypes;
 
 TYPED_TEST_CASE(FDR_Loadval, LoadvalTypes);
 
@@ -114,73 +85,6 @@ TYPED_TEST(FDR_Loadval, Normal) {
     }
 }
 
-TYPED_TEST(FDR_Loadval, Aligned) {
-    const size_t len = sizeof(TypeParam);
-    aligned_unique_ptr<u8> mem_p = aligned_zmalloc_unique<u8>(len); // 16 aligned
-    u8 * mem = mem_p.get();
-    ASSERT_TRUE(ISALIGNED_16(mem));
-    fillWithBytes(mem, len);
-
-    TypeParam val = lv_a<TypeParam>(mem, mem, mem + len);
-
-    // Should be identical to 'mem' in byte order.
-    ASSERT_EQ(0, memcmp(&val, mem, len));
-}
-
-TYPED_TEST(FDR_Loadval, CautiousForward) {
-    // For a cautious forward load, we will get zeroes for all bytes after the
-    // 'hi' ptr.
-    const size_t len = sizeof(TypeParam);
-
-    aligned_unique_ptr<u8> mem_p = aligned_zmalloc_unique<u8>(len + 1);
-    u8 *mem = mem_p.get() + 1; // force unaligned
-    fillWithBytes(mem, len);
-
-    for (size_t i = 1; i <= len; i++) {
-        const u8 *ptr = mem;
-        const u8 *lo = ptr;
-        const u8 *hi = ptr + i;
-        union {
-            TypeParam val;
-            u8 bytes[sizeof(TypeParam)];
-        } x;
-
-        x.val = lv_cf<TypeParam>(ptr, lo, hi);
-
-        // Low bytes will be correct, bytes >= hi will be zero.
-        for (size_t j = 0; j < len; j++) {
-            ASSERT_EQ(j < i ? mem[j] : 0, x.bytes[j]);
-        }
-    }
-}
-
-TYPED_TEST(FDR_Loadval, CautiousBackward) {
-    // For a cautious backwards load, we will get zeroes for all bytes before
-    // the 'lo' ptr.
-    const size_t len = sizeof(TypeParam);
-
-    aligned_unique_ptr<u8> mem_p = aligned_zmalloc_unique<u8>(len + 1);
-    u8 *mem = mem_p.get() + 1; // force unaligned
-    fillWithBytes(mem, len);
-
-    for (size_t i = 1; i <= len; i++) {
-        const u8 *ptr = mem;
-        const u8 *lo = ptr + sizeof(TypeParam) - i;
-        const u8 *hi = ptr + sizeof(TypeParam);
-        union {
-            TypeParam val;
-            u8 bytes[sizeof(TypeParam)];
-        } x;
-
-        x.val = lv_cb<TypeParam>(ptr, lo, hi);
-
-        // Low bytes will be zero, bytes >= lo will be correct.
-        for (size_t j = 0; j < len; j++) {
-            ASSERT_EQ(j < sizeof(TypeParam) - i ? 0 : mem[j], x.bytes[j]);
-        }
-    }
-}
-
 TYPED_TEST(FDR_Loadval, CautiousEverywhere) {
     // For a cautious backwards load, we will get zeroes for all bytes before
     // the 'lo' ptr or after the 'hi' ptr.
diff --git a/unit/internal/lbr.cpp b/unit/internal/lbr.cpp
index 00606141..2bb359df 100644
--- a/unit/internal/lbr.cpp
+++ b/unit/internal/lbr.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -36,7 +36,6 @@
 #include "nfa/nfa_internal.h"
 #include "nfa/nfa_api_util.h"
 #include "nfagraph/ng_lbr.h"
-#include "scratch.h"
 #include "util/alloc.h"
 #include "util/compile_context.h"
 #include "grey.h"
@@ -50,6 +49,8 @@ using namespace std;
 using namespace testing;
 using namespace ue2;
 
+static constexpr u32 MATCH_REPORT = 1024;
+
 struct LbrTestParams {
     CharReach reach;
     u32 min;
@@ -99,10 +100,11 @@ protected:
 
         ASSERT_TRUE(isLBR(*g, grey));
 
-        vector<vector<CharReach> > triggers;
-        triggers.push_back(vector<CharReach>());
-        triggers.back().push_back(CharReach::dot()); /* lbr triggered by . */
-        nfa = constructLBR(*g, triggers, cc);
+        rm.setProgramOffset(0, MATCH_REPORT);
+
+        /* LBR triggered by dot */
+        vector<vector<CharReach>> triggers = {{CharReach::dot()}};
+        nfa = constructLBR(*g, triggers, cc, rm);
         ASSERT_TRUE(nfa != nullptr);
 
         full_state = aligned_zmalloc_unique<char>(nfa->scratchStateSize);
@@ -120,7 +122,6 @@ protected:
         q.length = 0; // filled in by test
         q.history = nullptr;
         q.hlength = 0;
-        q.scratch = nullptr; // not needed by LBR
         q.report_current = 0;
         q.cb = onMatch;
         q.som_cb = nullptr; // only used by Haig
@@ -156,9 +157,6 @@ protected:
     // Space for stream state.
     aligned_unique_ptr<char> stream_state;
 
-    // Space for NFAContext structure.
-    aligned_unique_ptr<void> nfa_context;
-
     // Queue structure.
     struct mq q;
 };
@@ -252,7 +250,7 @@ TEST_P(LbrTest, QueueExecToMatch) {
     char rv = nfaQueueExecToMatch(nfa.get(), &q, end);
     ASSERT_EQ(MO_MATCHES_PENDING, rv);
     ASSERT_EQ(0, matches);
-    ASSERT_NE(0, nfaInAcceptState(nfa.get(), 0, &q));
+    ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q));
     nfaReportCurrentMatches(nfa.get(), &q);
     ASSERT_EQ(1, matches);
 }
diff --git a/unit/internal/limex_nfa.cpp b/unit/internal/limex_nfa.cpp
index 989c7b60..91ab09db 100644
--- a/unit/internal/limex_nfa.cpp
+++ b/unit/internal/limex_nfa.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -39,7 +39,6 @@
 #include "nfa/nfa_api.h"
 #include "nfa/nfa_api_util.h"
 #include "nfa/nfa_internal.h"
-#include "scratch.h"
 #include "util/alloc.h"
 #include "util/target_info.h"
 
@@ -47,7 +46,9 @@ using namespace std;
 using namespace testing;
 using namespace ue2;
 
-static const string SCAN_DATA = "___foo______\n___foofoo_foo_^^^^^^^^^^^^^^^^^^^^^^__bar_bar______0_______z_____bar";
+static const string SCAN_DATA = "___foo______\n___foofoo_foo_^^^^^^^^^^^^^^^^^^"
+                                "^^^^__bar_bar______0_______z_____bar";
+static const u32 MATCH_REPORT = 1024;
 
 static
 int onMatch(u64a, ReportID, void *ctx) {
@@ -76,6 +77,8 @@ protected:
         unique_ptr<NGWrapper> g = buildWrapper(rm, cc, parsed);
         ASSERT_TRUE(g != nullptr);
 
+        rm.setProgramOffset(0, MATCH_REPORT);
+
         const map<u32, u32> fixed_depth_tops;
         const map<u32, vector<vector<CharReach>>> triggers;
         bool compress_state = false;
@@ -86,12 +89,6 @@ protected:
 
         full_state = aligned_zmalloc_unique<char>(nfa->scratchStateSize);
         stream_state = aligned_zmalloc_unique<char>(nfa->streamStateSize);
-        nfa_context = aligned_zmalloc_unique<void>(sizeof(NFAContext512));
-
-        // Mock up a scratch structure that contains the pieces that we need
-        // for NFA execution.
-        scratch = aligned_zmalloc_unique<hs_scratch>(sizeof(struct hs_scratch));
-        scratch->nfaContext = nfa_context.get();
     }
 
     virtual void initQueue() {
@@ -105,7 +102,6 @@ protected:
         q.length = SCAN_DATA.size();
         q.history = nullptr;
         q.hlength = 0;
-        q.scratch = scratch.get();
         q.report_current = 0;
         q.cb = onMatch;
         q.som_cb = nullptr; // only used by Haig
@@ -127,12 +123,6 @@ protected:
     // Space for stream state.
     aligned_unique_ptr<char> stream_state;
 
-    // Space for NFAContext structure.
-    aligned_unique_ptr<void> nfa_context;
-
-    // Mock scratch.
-    aligned_unique_ptr<hs_scratch> scratch;
-
     // Queue structure.
     struct mq q;
 };
@@ -237,7 +227,7 @@ TEST_P(LimExModelTest, QueueExecToMatch) {
     char rv = nfaQueueExecToMatch(nfa.get(), &q, end);
     ASSERT_EQ(MO_MATCHES_PENDING, rv);
     ASSERT_EQ(0, matches);
-    ASSERT_NE(0, nfaInAcceptState(nfa.get(), 0, &q));
+    ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q));
     nfaReportCurrentMatches(nfa.get(), &q);
     ASSERT_EQ(1, matches);
 
@@ -246,7 +236,7 @@ TEST_P(LimExModelTest, QueueExecToMatch) {
     rv = nfaQueueExecToMatch(nfa.get(), &q, end);
     ASSERT_EQ(MO_MATCHES_PENDING, rv);
     ASSERT_EQ(1, matches);
-    ASSERT_NE(0, nfaInAcceptState(nfa.get(), 0, &q));
+    ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q));
     nfaReportCurrentMatches(nfa.get(), &q);
     ASSERT_EQ(2, matches);
 
@@ -255,7 +245,7 @@ TEST_P(LimExModelTest, QueueExecToMatch) {
     rv = nfaQueueExecToMatch(nfa.get(), &q, end);
     ASSERT_EQ(MO_MATCHES_PENDING, rv);
     ASSERT_EQ(2, matches);
-    ASSERT_NE(0, nfaInAcceptState(nfa.get(), 0, &q));
+    ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q));
     nfaReportCurrentMatches(nfa.get(), &q);
     ASSERT_EQ(3, matches);
 
@@ -281,10 +271,10 @@ TEST_P(LimExModelTest, QueueExecRose) {
     pushQueue(&q, MQE_TOP, 0);
     pushQueue(&q, MQE_END, end);
 
-    char rv = nfaQueueExecRose(nfa.get(), &q, 0 /* report id */);
+    char rv = nfaQueueExecRose(nfa.get(), &q, MATCH_REPORT);
     ASSERT_EQ(MO_MATCHES_PENDING, rv);
     pushQueue(&q, MQE_START, end);
-    ASSERT_NE(0, nfaInAcceptState(nfa.get(), 0, &q));
+    ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q));
 }
 
 TEST_P(LimExModelTest, CheckFinalState) {
@@ -333,13 +323,6 @@ protected:
 
         nfa = constructReversedNFA(g_rev, type, cc);
         ASSERT_TRUE(nfa != nullptr);
-
-        nfa_context = aligned_zmalloc_unique<void>(sizeof(NFAContext512));
-
-        // Mock up a scratch structure that contains the pieces that we need
-        // for reverse NFA execution.
-        scratch = aligned_zmalloc_unique<hs_scratch>(sizeof(struct hs_scratch));
-        scratch->nfaContextSom = nfa_context.get();
     }
 
     // NFA type (enum NFAEngineType)
@@ -350,12 +333,6 @@ protected:
 
     // Compiled NFA structure.
     aligned_unique_ptr<NFA> nfa;
-
-    // Space for NFAContext structure.
-    aligned_unique_ptr<void> nfa_context;
-
-    // Mock scratch.
-    aligned_unique_ptr<hs_scratch> scratch;
 };
 
 INSTANTIATE_TEST_CASE_P(LimExReverse, LimExReverseTest,
@@ -371,7 +348,7 @@ TEST_P(LimExReverseTest, BlockExecReverse) {
     const size_t hlen = 0;
 
     nfaBlockExecReverse(nfa.get(), offset, buf, buflen, hbuf, hlen,
-                        scratch.get(), onMatch, &matches);
+                        onMatch, &matches);
 
     ASSERT_EQ(3, matches);
 }
@@ -394,6 +371,8 @@ protected:
         unique_ptr<NGWrapper> g = buildWrapper(rm, cc, parsed);
         ASSERT_TRUE(g != nullptr);
 
+        rm.setProgramOffset(0, MATCH_REPORT);
+
         const map<u32, u32> fixed_depth_tops;
         const map<u32, vector<vector<CharReach>>> triggers;
         bool compress_state = false;
@@ -404,12 +383,6 @@ protected:
 
         full_state = aligned_zmalloc_unique<char>(nfa->scratchStateSize);
         stream_state = aligned_zmalloc_unique<char>(nfa->streamStateSize);
-        nfa_context = aligned_zmalloc_unique<void>(sizeof(NFAContext512));
-
-        // Mock up a scratch structure that contains the pieces that we need
-        // for NFA execution.
-        scratch = aligned_zmalloc_unique<hs_scratch>(sizeof(struct hs_scratch));
-        scratch->nfaContext = nfa_context.get();
     }
 
     virtual void initQueue() {
@@ -423,7 +396,6 @@ protected:
         q.length = ZOMBIE_SCAN_DATA.length();
         q.history = nullptr;
         q.hlength = 0;
-        q.scratch = scratch.get();
         q.report_current = 0;
         q.cb = onMatch;
         q.som_cb = nullptr; // only used by Haig
@@ -445,12 +417,6 @@ protected:
     // Space for stream state.
     aligned_unique_ptr<char> stream_state;
 
-    // Space for NFAContext structure.
-    aligned_unique_ptr<void> nfa_context;
-
-    // Mock scratch.
-    aligned_unique_ptr<hs_scratch> scratch;
-
     // Queue structure.
     struct mq q;
 };
diff --git a/unit/internal/multi_bit.cpp b/unit/internal/multi_bit.cpp
index 3f5c5908..925092b3 100644
--- a/unit/internal/multi_bit.cpp
+++ b/unit/internal/multi_bit.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -566,6 +566,24 @@ TEST_P(MultiBitTest, Any) {
     }
 }
 
+TEST_P(MultiBitTest, All) {
+    SCOPED_TRACE(test_size);
+    ASSERT_TRUE(ba != nullptr);
+
+    mmbit_clear(ba, test_size);
+    ASSERT_FALSE(mmbit_all(ba, test_size));
+
+    for (u64a i = 0; i < test_size - 1; i += stride) {
+        SCOPED_TRACE(i);
+        mmbit_set(ba, test_size, i);
+        ASSERT_FALSE(mmbit_all(ba, test_size));
+    }
+
+    // Set all bits.
+    fill_mmbit(ba, test_size);
+    ASSERT_TRUE(mmbit_all(ba, test_size));
+}
+
 TEST_P(MultiBitTest, UnsetRange1) {
     SCOPED_TRACE(test_size);
     ASSERT_TRUE(ba != nullptr);
diff --git a/unit/internal/multiaccel_matcher.cpp b/unit/internal/multiaccel_matcher.cpp
new file mode 100644
index 00000000..45a24f46
--- /dev/null
+++ b/unit/internal/multiaccel_matcher.cpp
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+extern "C" {
+#include "nfa/accel.h" // wrapping in extern C to make sure run_accel works
+}
+
+#include "config.h"
+#include "src/ue2common.h"
+
+#include "gtest/gtest.h"
+#include "nfagraph/ng_limex_accel.h"
+#include "nfa/accelcompile.h"
+#include "nfa/multivermicelli.h"
+#include "nfa/multishufti.h"
+#include "nfa/multitruffle.h"
+#include "util/alloc.h"
+#include "util/charreach.h"
+
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <stdlib.h>
+#include <iostream>
+
+using namespace ue2;
+using namespace std;
+using namespace testing;
+
+/*
+ * Static functions needed for this test's wellbeing
+ */
+
+// char generator
+static inline
+char getChar(const CharReach &cr, bool match) {
+    char result;
+    do {
+        result = rand() % CharReach::npos;
+    } while (cr.test(result) != match);
+    return result;
+}
+
+// appends a string with matches/unmatches according to input match pattern
+static
+void getMatch(u8 *result, u32 start, const string &pattern,
+              const CharReach &cr) {
+    for (const auto &c : pattern) {
+        result[start++] = getChar(cr, c == '1');
+    }
+}
+
+// appends non-matching noise of certain lengths
+static
+void getNoise(u8 *result, u32 start, u32 len, const CharReach &cr) {
+    for (unsigned i = 0; i < len; i++) {
+        result[start + i] = getChar(cr, false);
+    }
+}
+
+// test parameters structure
+struct MultiaccelTestParam {
+    string match_pattern;
+    u32 match_pattern_start_idx;
+    u32 match_idx;
+    bool test_all_offsets;
+    u8 match_len1;
+    u8 match_len2;
+    MultibyteAccelInfo::multiaccel_type type;
+};
+
+// buffer size is constant
+static const u32 BUF_SIZE = 200;
+
+// strings, out of which CharReach will be generated
+static const string VERM_CR = "a";
+static const string V_NC_CR = "aA";
+static const string SHUF_CR = "abcdefghijklmnopqrstuvwxyz";
+static const string TRUF_CR = "\x11\x22\x33\x44\x55\x66\x77\x88\x99";
+
+// Parameterized test case for multiaccel patterns.
+class MultiaccelTest : public TestWithParam<MultiaccelTestParam> {
+protected:
+    virtual void SetUp() {
+        // set up is deferred until the actual test, since we can't compile
+        // any accel schemes unless we know CharReach
+        const MultiaccelTestParam &p = GetParam();
+
+        // reserve space in our buffer
+        buffer = (u8 *)aligned_zmalloc(BUF_SIZE);
+
+        // store the index where we expect to see the match. note that it may
+        // be different from where the match pattern has started since we may
+        // have a flooded match (i.e. a match preceded by almost-match) or a
+        // no-match (in which case "match" index is at the end of the buffer).
+        match_idx = p.match_idx;
+
+        // make note if we need to test all offsets - sometimes we don't, for
+        // example when testing partial or no-match.
+        test_all_offsets = p.test_all_offsets;
+    }
+
+    // deferred buffer generation, as we don't know CharReach before we run the test
+    void GenerateBuffer(const CharReach &cr) {
+        const MultiaccelTestParam &p = GetParam();
+
+        // step 1: fill prefix with non-matching noise
+        u32 start = 0;
+        getNoise(buffer, start, p.match_pattern_start_idx, cr);
+
+        // step 2: add a match
+        start += p.match_pattern_start_idx;
+        getMatch(buffer, start, p.match_pattern, cr);
+
+        // step 3: fill in the rest of the buffer with non-matching noise
+        start += p.match_pattern.size();
+        getNoise(buffer, start, BUF_SIZE - p.match_pattern.size() -
+                 p.match_pattern_start_idx, cr);
+    }
+
+    // deferred accel scheme generation, as we don't know CharReach before we run the test
+    void CompileAccelScheme(const CharReach &cr, AccelAux *aux) {
+        const MultiaccelTestParam &p = GetParam();
+
+        AccelInfo ai;
+        ai.single_stops = cr; // dummy CharReach to prevent red tape accel
+        ai.ma_len1 = p.match_len1;
+        ai.ma_len2 = p.match_len2;
+        ai.multiaccel_stops = cr;
+        ai.ma_type = p.type;
+
+        buildAccelAux(ai, aux);
+
+        // now, verify we've successfully built our accel scheme, *and* that it's
+        // a multibyte scheme
+        ASSERT_TRUE(aux->accel_type >= ACCEL_MLVERM &&
+                    aux->accel_type <= ACCEL_MDSGTRUFFLE);
+    }
+
+    virtual void TearDown() {
+        aligned_free(buffer);
+    }
+
+    u32 match_idx;
+    u8 *buffer;
+    bool test_all_offsets;
+};
+
+static
+void runTest(const u8 *buffer, AccelAux *aux, unsigned match_idx,
+             bool test_all_offsets) {
+    const u8 *start = buffer;
+    const u8 *end = start + BUF_SIZE;
+    const u8 *match = start + match_idx;
+
+    // comparing indexes into the buffer is easier to understand than pointers
+    if (test_all_offsets) {
+        // run_accel can only scan >15 byte buffers
+        u32 end_offset = min(match_idx, BUF_SIZE - 15);
+
+        for (unsigned offset = 0; offset < end_offset; offset++) {
+            const u8 *ptr = run_accel(aux, (start + offset), end);
+            unsigned idx = ptr - start;
+            ASSERT_EQ(match_idx, idx);
+        }
+    } else {
+        const u8 *ptr = run_accel(aux, start, end);
+        unsigned idx = ptr - start;
+        ASSERT_EQ(match_idx, idx);
+    }
+}
+
+TEST_P(MultiaccelTest, TestVermicelli) {
+    AccelAux aux = {0};
+    CharReach cr(VERM_CR);
+
+    GenerateBuffer(cr);
+
+    CompileAccelScheme(cr, &aux);
+
+    runTest(buffer, &aux, match_idx, test_all_offsets);
+}
+
+TEST_P(MultiaccelTest, TestVermicelliNocase) {
+    AccelAux aux = {0};
+    CharReach cr(V_NC_CR);
+
+    GenerateBuffer(cr);
+
+    CompileAccelScheme(cr, &aux);
+
+    runTest(buffer, &aux, match_idx, test_all_offsets);
+}
+
+TEST_P(MultiaccelTest, TestShufti) {
+    AccelAux aux = {0};
+    CharReach cr(SHUF_CR);
+
+    GenerateBuffer(cr);
+
+    CompileAccelScheme(cr, &aux);
+
+    runTest(buffer, &aux, match_idx, test_all_offsets);
+}
+
+TEST_P(MultiaccelTest, TestTruffle) {
+    AccelAux aux = {0};
+    CharReach cr(TRUF_CR);
+
+    GenerateBuffer(cr);
+
+    CompileAccelScheme(cr, &aux);
+
+    runTest(buffer, &aux, match_idx, test_all_offsets);
+}
+
+static const MultiaccelTestParam multiaccelTests[] = {
+    // long matcher
+
+    // full, partial, flooded, nomatch
+    {"11111", 180, 180, true, 5, 0, MultibyteAccelInfo::MAT_LONG},
+    {"111", 197, 197, true, 5, 0, MultibyteAccelInfo::MAT_LONG},
+    {"1111011111", 177, 182, false, 5, 0, MultibyteAccelInfo::MAT_LONG},
+    {"1111011110", 177, 200, false, 5, 0, MultibyteAccelInfo::MAT_LONG},
+
+    // long-grab matcher
+
+    // full, partial, flooded, nomatch
+    {"111110", 180, 180, true, 5, 0, MultibyteAccelInfo::MAT_LONGGRAB},
+    {"111", 197, 197, true, 5, 0, MultibyteAccelInfo::MAT_LONGGRAB},
+    {"11111111110", 177, 182, false, 5, 0, MultibyteAccelInfo::MAT_LONGGRAB},
+    {"11110111101", 177, 200, false, 5, 0, MultibyteAccelInfo::MAT_LONGGRAB},
+
+    // shift matcher
+
+    // full, partial, flooded, nomatch
+    {"11001", 180, 180, true, 4, 0, MultibyteAccelInfo::MAT_SHIFT},
+    {"110", 197, 197, true, 4, 0, MultibyteAccelInfo::MAT_SHIFT},
+    {"1001011001", 177, 182, false, 4, 0, MultibyteAccelInfo::MAT_SHIFT},
+    {"1101001011", 177, 200, false, 4, 0, MultibyteAccelInfo::MAT_SHIFT},
+
+    // shift-grab matcher
+
+    // full, partial, flooded, nomatch
+    {"10111", 180, 180, true, 4, 0, MultibyteAccelInfo::MAT_SHIFTGRAB},
+    {"101", 197, 197, true, 4, 0, MultibyteAccelInfo::MAT_SHIFTGRAB},
+    {"1110010111", 177, 182, false, 4, 0, MultibyteAccelInfo::MAT_SHIFTGRAB},
+    {"1100101100", 177, 200, false, 4, 0, MultibyteAccelInfo::MAT_SHIFTGRAB},
+
+    // doubleshift matcher
+
+    // full, partial (one and two shifts), flooded, nomatch
+    {"110111", 180, 180, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFT},
+    {"110", 197, 197, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFT},
+    {"1101", 196, 196, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFT},
+    {"1100100101", 178, 182, false, 3, 2, MultibyteAccelInfo::MAT_DSHIFT},
+    {"1101001101", 177, 200, false, 3, 2, MultibyteAccelInfo::MAT_DSHIFT},
+
+    // doubleshift-grab matcher
+
+    // full, partial (one and two shifts), flooded, nomatch
+    {"100101", 180, 180, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB},
+    {"100", 197, 197, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB},
+    {"1011", 196, 196, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB},
+    {"11111101101", 177, 182, false, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB},
+    {"1111110111", 177, 200, false, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB},
+};
+
+INSTANTIATE_TEST_CASE_P(Multiaccel, MultiaccelTest, ValuesIn(multiaccelTests));
+
+// boring stuff for google test
+void PrintTo(const MultiaccelTestParam &p, ::std::ostream *os) {
+    *os << "MultiaccelTestParam: " << p.match_pattern;
+}
diff --git a/unit/internal/multiaccel_shift.cpp b/unit/internal/multiaccel_shift.cpp
new file mode 100644
index 00000000..d6019870
--- /dev/null
+++ b/unit/internal/multiaccel_shift.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "src/ue2common.h"
+
+#include "gtest/gtest.h"
+#include "nfa/multiaccel_common.h"
+
+/*
+ * Unit tests for the shifters.
+ *
+ * This is a bit messy, as shifters are macros, so we're using macros to test
+ * other macros.
+ */
+
+#define TEST_SHIFT(n) \
+    do { \
+        u64a val = ((u64a) 1 << n) - 1; \
+        JOIN(SHIFT, n)(val); \
+        ASSERT_EQ(val, 1); \
+    } while (0)
+
+TEST(MultiaccelShift, StaticShift) {
+    TEST_SHIFT(1);
+    TEST_SHIFT(2);
+    TEST_SHIFT(3);
+    TEST_SHIFT(4);
+    TEST_SHIFT(5);
+    TEST_SHIFT(6);
+    TEST_SHIFT(7);
+    TEST_SHIFT(8);
+    TEST_SHIFT(10);
+    TEST_SHIFT(11);
+    TEST_SHIFT(12);
+    TEST_SHIFT(13);
+    TEST_SHIFT(14);
+    TEST_SHIFT(15);
+    TEST_SHIFT(16);
+    TEST_SHIFT(17);
+    TEST_SHIFT(18);
+    TEST_SHIFT(19);
+    TEST_SHIFT(20);
+    TEST_SHIFT(21);
+    TEST_SHIFT(22);
+    TEST_SHIFT(23);
+    TEST_SHIFT(24);
+    TEST_SHIFT(25);
+    TEST_SHIFT(26);
+    TEST_SHIFT(27);
+    TEST_SHIFT(28);
+    TEST_SHIFT(29);
+    TEST_SHIFT(30);
+    TEST_SHIFT(31);
+    TEST_SHIFT(32);
+}
diff --git a/unit/internal/nfagraph_repeat.cpp b/unit/internal/nfagraph_repeat.cpp
index 53506b83..2473d755 100644
--- a/unit/internal/nfagraph_repeat.cpp
+++ b/unit/internal/nfagraph_repeat.cpp
@@ -103,3 +103,9 @@ TEST_P(NFAPureRepeatTest, Check) {
     ASSERT_EQ(t.minBound, repeat.bounds.min);
     ASSERT_EQ(t.maxBound, repeat.bounds.max);
 }
+
+// for google test
+void PrintTo(const PureRepeatTest &p, ::std::ostream *os) {
+    *os << "PureRepeatTest: " << p.pattern
+        << "{" << p.minBound << ',' << p.maxBound << '}';
+}
diff --git a/unit/internal/nfagraph_width.cpp b/unit/internal/nfagraph_width.cpp
index 81c49532..03508ea8 100644
--- a/unit/internal/nfagraph_width.cpp
+++ b/unit/internal/nfagraph_width.cpp
@@ -84,3 +84,14 @@ TEST_P(NFAWidthTest, Check) {
     ASSERT_EQ(t.minWidth, findMinWidth(*w));
     ASSERT_EQ(t.maxWidth, findMaxWidth(*w));
 }
+
+// for google test
+void PrintTo(const WidthTest &w, ::std::ostream *os) {
+    *os << "WidthTest: " << w.pattern << "{" << w.minWidth << ',';
+    if (w.maxWidth == depth::infinity()) {
+        *os << "inf";
+    } else {
+        *os << w.maxWidth;
+    }
+    *os << '}';
+}
diff --git a/unit/internal/noodle.cpp b/unit/internal/noodle.cpp
index 56fcc8f0..5df66236 100644
--- a/unit/internal/noodle.cpp
+++ b/unit/internal/noodle.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -32,7 +32,9 @@
 #include "hwlm/noodle_build.h"
 #include "hwlm/noodle_engine.h"
 #include "hwlm/hwlm.h"
+#include "hwlm/hwlm_literal.h"
 #include "util/alloc.h"
+#include "util/ue2string.h"
 
 #include <cstring>
 #include <vector>
@@ -64,9 +66,11 @@ hwlmcb_rv_t hlmSimpleCallback(size_t from, size_t to, u32 id, void *context) {
 }
 
 static
-void noodleMatch(const u8 *data, size_t data_len, const u8 *lit, size_t lit_len,
-                 char nocase, HWLMCallback cb, void *ctxt) {
-    auto n = noodBuildTable(lit, lit_len, nocase, 0);
+void noodleMatch(const u8 *data, size_t data_len, const char *lit_str,
+                 size_t lit_len, char nocase, HWLMCallback cb, void *ctxt) {
+    u32 id = 1000;
+    hwlmLiteral lit(std::string(lit_str, lit_len), nocase, id);
+    auto n = noodBuildTable(lit);
     ASSERT_TRUE(n != nullptr);
 
     hwlm_error_t rv;
@@ -82,8 +86,7 @@ TEST(Noodle, nood1) {
 
     memset(data, 'a', data_len);
 
-    noodleMatch(data, data_len, (const u8 *)"a", 1, 0, hlmSimpleCallback,
-                &ctxt);
+    noodleMatch(data, data_len, "a", 1, 0, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(1024U, ctxt.size());
     for (i = 0; i < 1024; i++) {
         ASSERT_EQ(i, ctxt[i].from);
@@ -91,13 +94,11 @@ TEST(Noodle, nood1) {
     }
 
     ctxt.clear();
-    noodleMatch(data, data_len, (const u8 *)"A", 1, 0,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "A", 1, 0, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(0U, ctxt.size());
 
     ctxt.clear();
-    noodleMatch(data, data_len, (const u8 *)"A", 1, 1,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "A", 1, 1, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(1024U, ctxt.size());
     for (i = 0; i < 1024; i++) {
         ASSERT_EQ(i, ctxt[i].from);
@@ -106,8 +107,8 @@ TEST(Noodle, nood1) {
 
     for (j = 0; j < 16; j++) {
         ctxt.clear();
-        noodleMatch(data + j, data_len - j, (const u8 *)"A", 1, 1,
-                             hlmSimpleCallback, &ctxt);
+        noodleMatch(data + j, data_len - j, "A", 1, 1, hlmSimpleCallback,
+                    &ctxt);
         ASSERT_EQ(1024 - j, ctxt.size());
         for (i = 0; i < 1024 - j; i++) {
             ASSERT_EQ(i, ctxt[i].from);
@@ -115,8 +116,7 @@ TEST(Noodle, nood1) {
         }
 
         ctxt.clear();
-        noodleMatch(data, data_len - j, (const u8 *)"A", 1, 1,
-                             hlmSimpleCallback, &ctxt);
+        noodleMatch(data, data_len - j, "A", 1, 1, hlmSimpleCallback, &ctxt);
         ASSERT_EQ(1024 - j, ctxt.size());
         for (i = 0; i < 1024 - j; i++) {
             ASSERT_EQ(i, ctxt[i].from);
@@ -133,8 +133,7 @@ TEST(Noodle, nood2) {
 
     memset(data, 'a', data_len);
 
-    noodleMatch(data, data_len, (const u8 *)"aa", 2, 0,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "aa", 2, 0, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(1023U, ctxt.size());
     for (i = 0; i < 1023; i++) {
         ASSERT_EQ(i, ctxt[i].from);
@@ -142,18 +141,15 @@ TEST(Noodle, nood2) {
     }
 
     ctxt.clear();
-    noodleMatch(data, data_len, (const u8 *)"aA", 2, 0,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "aA", 2, 0, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(0U, ctxt.size());
 
     ctxt.clear();
-    noodleMatch(data, data_len, (const u8 *)"AA", 2, 0,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "AA", 2, 0, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(0U, ctxt.size());
 
     ctxt.clear();
-    noodleMatch(data, data_len, (const u8 *)"aa", 2, 1,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "aa", 2, 1, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(1023U, ctxt.size());
     for (i = 0; i < 1023; i++) {
         ASSERT_EQ(i, ctxt[i].from);
@@ -161,8 +157,7 @@ TEST(Noodle, nood2) {
     }
 
     ctxt.clear();
-    noodleMatch(data, data_len, (const u8 *)"Aa", 2, 1,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "Aa", 2, 1, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(1023U, ctxt.size());
     for (i = 0; i < 1023; i++) {
         ASSERT_EQ(i, ctxt[i].from);
@@ -170,8 +165,7 @@ TEST(Noodle, nood2) {
     }
 
     ctxt.clear();
-    noodleMatch(data, data_len, (const u8 *)"AA", 2, 1,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "AA", 2, 1, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(1023U, ctxt.size());
     for (i = 0; i < 1023; i++) {
         ASSERT_EQ(i, ctxt[i].from);
@@ -180,8 +174,8 @@ TEST(Noodle, nood2) {
 
     for (j = 0; j < 16; j++) {
         ctxt.clear();
-        noodleMatch(data + j, data_len - j, (const u8 *)"Aa", 2, 1,
-                             hlmSimpleCallback, &ctxt);
+        noodleMatch(data + j, data_len - j, "Aa", 2, 1, hlmSimpleCallback,
+                    &ctxt);
         ASSERT_EQ(1023 - j, ctxt.size());
         for (i = 0; i < 1023 - j; i++) {
             ASSERT_EQ(i, ctxt[i].from);
@@ -189,8 +183,7 @@ TEST(Noodle, nood2) {
         }
 
         ctxt.clear();
-        noodleMatch(data, data_len - j, (const u8 *)"aA", 2, 1,
-                             hlmSimpleCallback, &ctxt);
+        noodleMatch(data, data_len - j, "aA", 2, 1, hlmSimpleCallback, &ctxt);
         ASSERT_EQ(1023 - j, ctxt.size());
         for (i = 0; i < 1023 - j; i++) {
             ASSERT_EQ(i, ctxt[i].from);
@@ -207,8 +200,7 @@ TEST(Noodle, noodLong) {
 
     memset(data, 'a', data_len);
 
-    noodleMatch(data, data_len, (const u8 *)"aaaa", 4, 0,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "aaaa", 4, 0, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(1021U, ctxt.size());
     for (i = 0; i < 1021; i++) {
         ASSERT_EQ(i, ctxt[i].from);
@@ -216,13 +208,11 @@ TEST(Noodle, noodLong) {
     }
 
     ctxt.clear();
-    noodleMatch(data, data_len, (const u8 *)"aaAA", 4, 0,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "aaAA", 4, 0, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(0U, ctxt.size());
 
     ctxt.clear();
-    noodleMatch(data, data_len, (const u8 *)"aaAA", 4, 1,
-                         hlmSimpleCallback, &ctxt);
+    noodleMatch(data, data_len, "aaAA", 4, 1, hlmSimpleCallback, &ctxt);
     ASSERT_EQ(1021U, ctxt.size());
     for (i = 0; i < 1021; i++) {
         ASSERT_EQ(i, ctxt[i].from);
@@ -231,8 +221,8 @@ TEST(Noodle, noodLong) {
 
     for (j = 0; j < 16; j++) {
         ctxt.clear();
-        noodleMatch(data + j, data_len -j, (const u8 *)"AAaa", 4, 1,
-                             hlmSimpleCallback, &ctxt);
+        noodleMatch(data + j, data_len - j, "AAaa", 4, 1, hlmSimpleCallback,
+                    &ctxt);
         ASSERT_EQ(1021 - j, ctxt.size());
         for (i = 0; i < 1021 - j; i++) {
             ASSERT_EQ(i, ctxt[i].from);
@@ -240,8 +230,8 @@ TEST(Noodle, noodLong) {
         }
 
         ctxt.clear();
-        noodleMatch(data + j, data_len -j, (const u8 *)"aaaA", 4, 1,
-                             hlmSimpleCallback, &ctxt);
+        noodleMatch(data + j, data_len - j, "aaaA", 4, 1, hlmSimpleCallback,
+                    &ctxt);
         ASSERT_EQ(1021 - j, ctxt.size());
         for (i = 0; i < 1021 - j; i++) {
             ASSERT_EQ(i, ctxt[i].from);
@@ -260,8 +250,7 @@ TEST(Noodle, noodCutoverSingle) {
     for (u32 align = 0; align < 16; align++) {
         for (u32 len = 0; len < max_data_len; len++) {
             ctxt.clear();
-            noodleMatch(data + align, len, (const u8 *)"a", 1, 0,
-                    hlmSimpleCallback, &ctxt);
+            noodleMatch(data + align, len, "a", 1, 0, hlmSimpleCallback, &ctxt);
             EXPECT_EQ(len, ctxt.size());
             for (u32 i = 0; i < ctxt.size(); i++) {
                 ASSERT_EQ(i, ctxt[i].from);
@@ -281,9 +270,9 @@ TEST(Noodle, noodCutoverDouble) {
     for (u32 align = 0; align < 16; align++) {
         for (u32 len = 0; len < max_data_len; len++) {
             ctxt.clear();
-            noodleMatch(data + align, len, (const u8 *)"aa", 2, 0,
-                    hlmSimpleCallback, &ctxt);
-            EXPECT_EQ(len ? len - 1 : 0U , ctxt.size());
+            noodleMatch(data + align, len, "aa", 2, 0, hlmSimpleCallback,
+                        &ctxt);
+            EXPECT_EQ(len ? len - 1 : 0U, ctxt.size());
             for (u32 i = 0; i < ctxt.size(); i++) {
                 ASSERT_EQ(i, ctxt[i].from);
                 ASSERT_EQ(i + 1, ctxt[i].to);
diff --git a/unit/internal/repeat.cpp b/unit/internal/repeat.cpp
index 94f1bdc1..7f245e62 100644
--- a/unit/internal/repeat.cpp
+++ b/unit/internal/repeat.cpp
@@ -193,7 +193,9 @@ static const RepeatTestInfo repeatTests[] = {
     { REPEAT_FIRST, 100, depth::infinity() },
     { REPEAT_FIRST, 1000, depth::infinity() },
     { REPEAT_FIRST, 3000, depth::infinity() },
-    { REPEAT_FIRST, 10000, depth::infinity() }
+    { REPEAT_FIRST, 10000, depth::infinity() },
+    // {,} repeats -- always
+    { REPEAT_ALWAYS, 0, depth::infinity() },
 };
 
 INSTANTIATE_TEST_CASE_P(Repeat, RepeatTest, ValuesIn(repeatTests));
@@ -289,6 +291,10 @@ TEST_P(RepeatTest, FillRing) {
 
 TEST_P(RepeatTest, FindTops) {
     SCOPED_TRACE(testing::Message() << "Repeat: " << info);
+    /* REPEAT_ALWAYS has no state and so does not track top locations */
+    if (info.type == REPEAT_ALWAYS) {
+        return;
+    }
 
     repeatStore(&info, ctrl, state, 1000, 0);
     ASSERT_EQ(1000, repeatLastTop(&info, ctrl, state));
@@ -364,7 +370,8 @@ TEST_P(RepeatTest, TwoTops) {
     SCOPED_TRACE(testing::Message() << "Repeat: " << info);
 
     // Only appropriate for tests that store more than one top.
-    if (info.type == REPEAT_FIRST || info.type == REPEAT_LAST) {
+    if (info.type == REPEAT_FIRST || info.type == REPEAT_LAST
+        || info.type == REPEAT_ALWAYS) {
         return;
     }
 
diff --git a/unit/internal/shufti.cpp b/unit/internal/shufti.cpp
index ed48ad5c..b8d77d37 100644
--- a/unit/internal/shufti.cpp
+++ b/unit/internal/shufti.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -283,7 +283,9 @@ TEST(DoubleShufti, BuildMask1) {
 
     lits.insert(make_pair('a', 'B'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m, &lo2m, &hi2m);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
+                                     &lo2m, &hi2m);
+    ASSERT_TRUE(rv);
 
     u8 *lo1 = (u8 *)&lo1m;
     u8 *lo2 = (u8 *)&lo2m;
@@ -324,7 +326,9 @@ TEST(DoubleShufti, BuildMask2) {
     lits.insert(make_pair('a','z'));
     lits.insert(make_pair('B','z'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m, &lo2m, &hi2m);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
+                                     &lo2m, &hi2m);
+    ASSERT_TRUE(rv);
 
     u8 *lo1 = (u8 *)&lo1m;
     u8 *lo2 = (u8 *)&lo2m;
@@ -350,7 +354,9 @@ TEST(DoubleShufti, BuildMask4) {
     lits.insert(make_pair('A','z'));
     lits.insert(make_pair('b','z'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m, &lo2m, &hi2m);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
+                                     &lo2m, &hi2m);
+    ASSERT_TRUE(rv);
 
     u8 *lo1 = (u8 *)&lo1m;
     u8 *lo2 = (u8 *)&lo2m;
@@ -377,7 +383,9 @@ TEST(DoubleShufti, BuildMask5) {
     CharReach bytes;
     bytes.set('X');
 
-    shuftiBuildDoubleMasks(bytes, lits, &lo1m, &hi1m, &lo2m, &hi2m);
+    bool rv = shuftiBuildDoubleMasks(bytes, lits, &lo1m, &hi1m,
+                                     &lo2m, &hi2m);
+    ASSERT_TRUE(rv);
 
     u8 *lo1 = (u8 *)&lo1m;
     u8 *lo2 = (u8 *)&lo2m;
@@ -395,6 +403,81 @@ TEST(DoubleShufti, BuildMask5) {
               lo1['B' % 16] | hi1['B' >> 4] | lo2['X' % 16] | hi2['X' >> 4]);
 }
 
+TEST(DoubleShufti, BuildMask6) {
+    m128 lo1m, hi1m, lo2m, hi2m;
+
+    flat_set<pair<u8, u8>> lits;
+
+    lits.insert(make_pair('a','z'));
+    lits.insert(make_pair('B','z'));
+    lits.insert(make_pair('A','z'));
+    lits.insert(make_pair('b','z'));
+    lits.insert(make_pair('a','y'));
+    lits.insert(make_pair('B','y'));
+    lits.insert(make_pair('A','y'));
+    lits.insert(make_pair('b','y'));
+    lits.insert(make_pair('a','x'));
+    lits.insert(make_pair('B','x'));
+    lits.insert(make_pair('A','x'));
+    lits.insert(make_pair('b','x'));
+
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
+                                     &lo2m, &hi2m);
+    ASSERT_TRUE(rv);
+
+    u8 *lo1 = (u8 *)&lo1m;
+    u8 *lo2 = (u8 *)&lo2m;
+    u8 *hi1 = (u8 *)&hi1m;
+    u8 *hi2 = (u8 *)&hi2m;
+    ASSERT_NE(0xff,
+              lo1['a' % 16] | hi1['a' >> 4] | lo2['z' % 16] | hi2['z' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['A' % 16] | hi1['A' >> 4] | lo2['z' % 16] | hi2['z' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['b' % 16] | hi1['b' >> 4] | lo2['z' % 16] | hi2['z' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['B' % 16] | hi1['B' >> 4] | lo2['z' % 16] | hi2['z' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['a' % 16] | hi1['a' >> 4] | lo2['y' % 16] | hi2['y' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['A' % 16] | hi1['A' >> 4] | lo2['y' % 16] | hi2['y' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['b' % 16] | hi1['b' >> 4] | lo2['y' % 16] | hi2['y' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['B' % 16] | hi1['B' >> 4] | lo2['y' % 16] | hi2['y' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['a' % 16] | hi1['a' >> 4] | lo2['x' % 16] | hi2['x' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['A' % 16] | hi1['A' >> 4] | lo2['x' % 16] | hi2['x' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['b' % 16] | hi1['b' >> 4] | lo2['x' % 16] | hi2['x' >> 4]);
+    ASSERT_NE(0xff,
+              lo1['B' % 16] | hi1['B' >> 4] | lo2['x' % 16] | hi2['x' >> 4]);
+}
+
+TEST(DoubleShufti, BuildMask7) {
+    m128 lo1m, hi1m, lo2m, hi2m;
+
+    flat_set<pair<u8, u8>> lits;
+
+    lits.insert(make_pair('a','b'));
+    lits.insert(make_pair('c','d'));
+    lits.insert(make_pair('e','f'));
+    lits.insert(make_pair('g','h'));
+    lits.insert(make_pair('i','j'));
+    lits.insert(make_pair('k','l'));
+    lits.insert(make_pair('m','n'));
+    lits.insert(make_pair('o','p'));
+    lits.insert(make_pair('q','r'));
+    lits.insert(make_pair('s','t'));
+    lits.insert(make_pair('u','v'));
+    lits.insert(make_pair('w','x'));
+
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
+                                     &lo2m, &hi2m);
+    ASSERT_FALSE(rv);
+}
+
 TEST(DoubleShufti, ExecNoMatch1) {
     m128 lo1, hi1, lo2, hi2;
 
@@ -402,7 +485,9 @@ TEST(DoubleShufti, ExecNoMatch1) {
 
     lits.insert(make_pair('a','b'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1,
+                                     &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
@@ -421,7 +506,8 @@ TEST(DoubleShufti, ExecNoMatch1b) {
 
     lits.insert(make_pair('b','a'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
@@ -441,7 +527,8 @@ TEST(DoubleShufti, ExecNoMatch2) {
     lits.insert(make_pair('a','b'));
     lits.insert(make_pair('B','b'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
@@ -461,7 +548,8 @@ TEST(DoubleShufti, ExecNoMatch2b) {
     lits.insert(make_pair('b','a'));
     lits.insert(make_pair('b','B'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
@@ -480,7 +568,8 @@ TEST(DoubleShufti, ExecNoMatch3) {
 
     lits.insert(make_pair('V','e'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 
@@ -499,7 +588,8 @@ TEST(DoubleShufti, ExecNoMatch3b) {
 
     lits.insert(make_pair('e','V'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 
@@ -518,7 +608,8 @@ TEST(DoubleShufti, ExecMatch1) {
 
     lits.insert(make_pair('a','b'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbb";
@@ -538,7 +629,8 @@ TEST(DoubleShufti, ExecMatch2) {
 
     lits.insert(make_pair('a','a'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb";
@@ -559,7 +651,8 @@ TEST(DoubleShufti, ExecMatch3) {
     lits.insert(make_pair('B','a'));
     lits.insert(make_pair('a','a'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbBaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb";
@@ -582,8 +675,8 @@ TEST(DoubleShufti, ExecMatch4) {
     lits.insert(make_pair('C','a'));
     lits.insert(make_pair('c','a'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
-
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbAaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb";
@@ -624,8 +717,8 @@ TEST(DoubleShufti, ExecMatch4b) {
     lits.insert(make_pair('a','C'));
     lits.insert(make_pair('a','c'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
-
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbaAaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb";
@@ -663,7 +756,8 @@ TEST(DoubleShufti, ExecMatch5) {
 
     lits.insert(make_pair('a','A'));
 
-    shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
@@ -686,7 +780,8 @@ TEST(DoubleShufti, ExecMatchMixed1) {
     // just one one-byte literal
     onebyte.set('a');
 
-    shuftiBuildDoubleMasks(onebyte, twobyte, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(onebyte, twobyte, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
@@ -709,7 +804,8 @@ TEST(DoubleShufti, ExecMatchMixed2) {
     onebyte.set('a');
     twobyte.insert(make_pair('x', 'y'));
 
-    shuftiBuildDoubleMasks(onebyte, twobyte, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(onebyte, twobyte, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
     char t2[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -742,7 +838,8 @@ TEST(DoubleShufti, ExecMatchMixed3) {
     onebyte.set('a');
     twobyte.insert(make_pair('x', 'y'));
 
-    shuftiBuildDoubleMasks(onebyte, twobyte, &lo1, &hi1, &lo2, &hi2);
+    bool rv = shuftiBuildDoubleMasks(onebyte, twobyte, &lo1, &hi1, &lo2, &hi2);
+    ASSERT_TRUE(rv);
 
     const int len = 420;
     char t1[len + 1];
diff --git a/unit/internal/sidecar.cpp b/unit/internal/sidecar.cpp
deleted file mode 100644
index bd517926..00000000
--- a/unit/internal/sidecar.cpp
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
- * Copyright (c) 2015, Intel Corporation
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of Intel Corporation nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-
-#include "ue2common.h"
-#include "sidecar/sidecar.h"
-#include "sidecar/sidecar_compile.h"
-#include "sidecar/sidecar_internal.h"
-#include "util/alloc.h"
-#include "util/charreach.h"
-
-#include <tuple>
-#include <vector>
-#include "gtest/gtest.h"
-
-using namespace testing;
-using namespace ue2;
-using std::vector;
-using std::set;
-using std::tie;
-using std::tuple;
-
-namespace {
-
-void ns_cb(UNUSED u64a offset, u32 id, void *ctxt) {
-    u32 *seen = (u32 *)ctxt;
-    *seen |= 1U << id;
-}
-
-void set_cb(UNUSED u64a offset, u32 id, void *ctxt) {
-    set<u32> *seen = (set<u32> *)ctxt;
-    seen->insert(id);
-}
-
-TEST(Sidecar, ns1) {
-    const size_t data_len = 1024;
-    u8 data[data_len];
-
-    CharReach c_1;
-    c_1.set('f');
-    vector<CharReach> charclasses;
-    charclasses.push_back(c_1);
-    auto ns = sidecarCompile(charclasses);
-
-    ASSERT_TRUE(ns != nullptr);
-    ASSERT_LT(0U, sidecarSize(ns.get()));
-
-    auto enabled =
-        aligned_zmalloc_unique<sidecar_enabled>(sidecarEnabledSize(ns.get()));
-    sidecarEnabledInit(ns.get(), enabled.get());
-    auto scratch =
-        aligned_zmalloc_unique<sidecar_scratch>(sidecarScratchSize(ns.get()));
-
-    for (u32 i = 0; i < 256; i++) {
-        SCOPED_TRACE(i);
-        u32 seen = 0;
-        memset(data, i, data_len);
-        sidecarExec(ns.get(), data, data_len, enabled.get(), scratch.get(), 0,
-                    ns_cb, &seen);
-        ASSERT_EQ(0U, seen);
-    }
-
-    sidecarEnabledAdd(ns.get(), enabled.get(), 0);
-
-    for (u32 i = 0; i < 256; i++) {
-        SCOPED_TRACE(i);
-        u32 seen = 0;
-        memset(data, i, data_len);
-        sidecarExec(ns.get(), data, data_len, enabled.get(), scratch.get(), 0,
-                    ns_cb, &seen);
-        if (i == 'f') {
-            ASSERT_EQ(1U, seen);
-        } else {
-            ASSERT_EQ(0U, seen);
-        }
-    }
-}
-
-const char* sidecarStrings[] = {
-    "f",
-    "a",
-    "A",
-    "ab",
-    "\r\n", // an old favourite
-    "\t\r\n",
-    " \r\n",
-    "xyz",
-    "z0y1",
-    "01234567", // 8 elements
-    "!@#$%^&*()", // 10 elements
-    "qwertyuiopasdfgh", // 16 elements
-    "qwertyuiopasdfghj", // 17 elements
-    "qwertyuiopasdfghjklzxcvb", // 24 elements
-    "qwertyuiopasdfghjklzxcvbnm012345", // 32 elements
-    "qwertyuiopasdfghjklzxcvbnm0123456" // 33 elements
-};
-
-const u32 sidecarModels[] = {
-    SIDECAR_8,
-    SIDECAR_32,
-    SIDECAR_64,
-    SIDECAR_128,
-    SIDECAR_256,
-    SIDECAR_N,
-    SIDECAR_S
-};
-
-// Number of elements we can handle in each model
-const u32 sidecarSizes[] = {
-    8,
-    32,
-    64,
-    128,
-    256,
-    1,
-    8
-};
-
-// Parameterized test case for string of single-byte classes
-class SidecarTest : public TestWithParam<tuple<u32, const char *>> {
-protected:
-    virtual void SetUp() {
-        tie(model, chars) = GetParam();
-        size_t num = strlen(chars);
-        charclasses.resize(num);
-
-        for (size_t i = 0; i < num; i++) {
-            charclasses[i].set(chars[i]);
-        }
-    }
-
-    virtual bool fitsModel() {
-        for (size_t i = 0; i < ARRAY_LENGTH(sidecarModels); i++) {
-            if (sidecarModels[i] == model) {
-                return charclasses.size() <= sidecarSizes[i];
-            }
-        }
-        return false;
-    }
-
-    u32 model;
-    const char *chars;
-    vector<CharReach> charclasses;
-};
-
-TEST_P(SidecarTest, Individual) {
-    SCOPED_TRACE(chars);
-
-    // Skip this test if the model is too small
-    if (!fitsModel()) {
-        return;
-    }
-
-    auto ns = sidecarCompile(charclasses, model);
-    if (!ns && model == SIDECAR_S) { /* shufti is fussi */
-        return;
-    }
-    ASSERT_TRUE(ns != nullptr);
-    ASSERT_LT(0U, sidecarSize(ns.get()));
-
-    auto enabled =
-        aligned_zmalloc_unique<sidecar_enabled>(sidecarEnabledSize(ns.get()));
-    sidecarEnabledInit(ns.get(), enabled.get());
-    auto local_enabled =
-        aligned_zmalloc_unique<sidecar_enabled>(sidecarEnabledSize(ns.get()));
-    auto scratch =
-        aligned_zmalloc_unique<sidecar_scratch>(sidecarScratchSize(ns.get()));
-
-    const size_t data_len = 1024;
-    u8 data[data_len];
-
-    // with nothing enabled, nothing should fire
-    for (u32 i = 0; i < 256; i++) {
-        SCOPED_TRACE(i);
-        memset(data, i, data_len);
-        set<u32> seen;
-        sidecarExec(ns.get(), data, data_len, enabled.get(), scratch.get(), 0,
-                    set_cb, &seen);
-        ASSERT_TRUE(seen.empty());
-    }
-
-    // test that every char class fires when enabled separately
-    for (u32 j = 0; j < charclasses.size(); j++) {
-        u32 c = chars[j];
-        SCOPED_TRACE(c);
-
-        // build a "compile time" enabled structure and add class j to it.
-        sidecarEnabledInit(ns.get(), local_enabled.get());
-        sidecarEnabledAdd(ns.get(), local_enabled.get(), j);
-
-        // union class j into our runtime enabled structure.
-        sidecarEnabledUnion(ns.get(), enabled.get(), local_enabled.get());
-
-        for (u32 i = 0; i < 256; i++) {
-            SCOPED_TRACE(i);
-            memset(data, i, data_len);
-            set<u32> seen;
-            sidecarExec(ns.get(), data, data_len, enabled.get(), scratch.get(),
-                        0, set_cb, &seen);
-            if (i == c) {
-                ASSERT_EQ(1U, seen.size());
-                ASSERT_EQ(j, *seen.begin());
-            } else {
-                ASSERT_TRUE(seen.empty());
-            }
-        }
-    }
-}
-
-TEST_P(SidecarTest, Together) {
-    SCOPED_TRACE(chars);
-
-    // Skip this test if the model is too small
-    if (!fitsModel()) {
-        return;
-    }
-
-    auto ns = sidecarCompile(charclasses, model);
-    if (!ns && model == SIDECAR_S) { /* shufti is fussi */
-        return;
-    }
-    ASSERT_TRUE(ns != nullptr);
-    ASSERT_LT(0U, sidecarSize(ns.get()));
-
-    auto enabled =
-        aligned_zmalloc_unique<sidecar_enabled>(sidecarEnabledSize(ns.get()));
-    sidecarEnabledInit(ns.get(), enabled.get());
-    auto local_enabled =
-        aligned_zmalloc_unique<sidecar_enabled>(sidecarEnabledSize(ns.get()));
-    auto scratch =
-        aligned_zmalloc_unique<sidecar_scratch>(sidecarScratchSize(ns.get()));
-
-    const size_t data_len = 1024;
-    u8 data[data_len];
-
-    // with nothing enabled, nothing should fire
-    for (u32 i = 0; i < 256; i++) {
-        SCOPED_TRACE(i);
-        memset(data, i, data_len);
-        set<u32> seen;
-        sidecarExec(ns.get(), data, data_len, enabled.get(), scratch.get(), 0,
-                    set_cb, &seen);
-        ASSERT_TRUE(seen.empty());
-    }
-
-    // test that every char class fires
-    for (u32 j = 0; j < charclasses.size(); j++) {
-        // enable the whole lot
-        sidecarEnabledInit(ns.get(), enabled.get());
-        for (u32 i = 0; i < charclasses.size(); i++) {
-            // build a "compile time" enabled structure and add class j to it.
-            sidecarEnabledInit(ns.get(), local_enabled.get());
-            sidecarEnabledAdd(ns.get(), local_enabled.get(), i);
-
-            // union class j into our runtime enabled structure.
-            sidecarEnabledUnion(ns.get(), enabled.get(), local_enabled.get());
-        }
-
-        u32 c = chars[j];
-        SCOPED_TRACE(c);
-
-        for (u32 i = 0; i < 256; i++) {
-            SCOPED_TRACE(i);
-            memset(data, i, data_len);
-            set<u32> seen;
-            sidecarExec(ns.get(), data, data_len, enabled.get(), scratch.get(),
-                        0, set_cb, &seen);
-            if (i == c) {
-                // seen should contain only `c'
-                ASSERT_EQ(1U, seen.size());
-                ASSERT_FALSE(seen.end() == seen.find(j));
-            } else {
-                // seen should not contain `c', and either zero or one char can
-                // have matched
-                ASSERT_GT(2U, seen.size());
-                ASSERT_TRUE(seen.end() == seen.find(j));
-            }
-        }
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Sidecar, SidecarTest,
-    Combine(ValuesIn(sidecarModels),
-            ValuesIn(sidecarStrings)));
-
-}
diff --git a/unit/internal/simd_utils.cpp b/unit/internal/simd_utils.cpp
index c0b2b2a0..de0f1eea 100644
--- a/unit/internal/simd_utils.cpp
+++ b/unit/internal/simd_utils.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -32,7 +32,7 @@
 #include "util/alloc.h"
 #include "util/make_unique.h"
 #include "util/simd_utils.h"
-
+#include "util/simd_utils_ssse3.h"
 
 using namespace std;
 using namespace ue2;
@@ -640,4 +640,58 @@ TEST(SimdUtilsTest, set2x128) {
 }
 #endif
 
+TEST(SimdUtilsTest, variableByteShift128) {
+    char base[] = "0123456789ABCDEF";
+    m128 in = loadu128(base);
+
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 0),
+                         variable_byte_shift_m128(in, 0)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 1),
+                         variable_byte_shift_m128(in, -1)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 2),
+                         variable_byte_shift_m128(in, -2)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 3),
+                         variable_byte_shift_m128(in, -3)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 4),
+                         variable_byte_shift_m128(in, -4)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 5),
+                         variable_byte_shift_m128(in, -5)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 6),
+                         variable_byte_shift_m128(in, -6)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 7),
+                         variable_byte_shift_m128(in, -7)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 8),
+                         variable_byte_shift_m128(in, -8)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 9),
+                         variable_byte_shift_m128(in, -9)));
+    EXPECT_TRUE(!diff128(byteShiftRight128(in, 10),
+                         variable_byte_shift_m128(in, -10)));
+
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 0),
+                         variable_byte_shift_m128(in, 0)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 1),
+                         variable_byte_shift_m128(in, 1)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 2),
+                         variable_byte_shift_m128(in, 2)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 3),
+                         variable_byte_shift_m128(in, 3)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 4),
+                         variable_byte_shift_m128(in, 4)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 5),
+                         variable_byte_shift_m128(in, 5)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 6),
+                         variable_byte_shift_m128(in, 6)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 7),
+                         variable_byte_shift_m128(in, 7)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 8),
+                         variable_byte_shift_m128(in, 8)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 9),
+                         variable_byte_shift_m128(in, 9)));
+    EXPECT_TRUE(!diff128(byteShiftLeft128(in, 10),
+                         variable_byte_shift_m128(in, 10)));
+
+    EXPECT_TRUE(!diff128(zeroes128(), variable_byte_shift_m128(in, 16)));
+    EXPECT_TRUE(!diff128(zeroes128(), variable_byte_shift_m128(in, -16)));
+}
+
 } // namespace
diff --git a/unit/internal/vermicelli.cpp b/unit/internal/vermicelli.cpp
index 4442754e..5d66a332 100644
--- a/unit/internal/vermicelli.cpp
+++ b/unit/internal/vermicelli.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -31,8 +31,6 @@
 #include "gtest/gtest.h"
 #include "nfa/vermicelli.h"
 
-#define BOUND (~(VERM_BOUNDARY - 1))
-
 TEST(Vermicelli, ExecNoMatch1) {
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
@@ -128,27 +126,27 @@ TEST(DoubleVermicelli, ExecNoMatch1) {
             const u8 *rv = vermicelliDoubleExec('a', 'b', 0, (u8 *)t1 + i,
                                                 (u8 *)t1 + strlen(t1) - j);
 
-            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1) & BOUND, (size_t)rv);
+            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1), (size_t)rv);
 
             rv = vermicelliDoubleExec('B', 'b', 0, (u8 *)t1 + i,
                                 (u8 *)t1 + strlen(t1) - j);
 
-            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1) & BOUND, (size_t)rv);
+            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1), (size_t)rv);
 
             rv = vermicelliDoubleExec('A', 'B', 1, (u8 *)t1 + i,
                                 (u8 *)t1 + strlen(t1) - j);
 
-            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1) & BOUND, (size_t)rv);
+            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1), (size_t)rv);
 
             rv = vermicelliDoubleExec('b', 'B', 0, (u8 *)t1 + i,
                                 (u8 *)t1 + strlen(t1) - j);
 
-            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1) & BOUND, (size_t)rv);
+            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1), (size_t)rv);
 
             rv = vermicelliDoubleExec('B', 'A', 1, (u8 *)t1 + i,
                                 (u8 *)t1 + strlen(t1) - j);
 
-            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1) & BOUND, (size_t)rv);
+            ASSERT_EQ(((size_t)t1 + strlen(t1) - j  - 1), (size_t)rv);
         }
     }
 }
@@ -345,3 +343,178 @@ TEST(NVermicelli, Exec4) {
     }
 }
 
+TEST(DoubleVermicelliMasked, ExecNoMatch1) {
+    std::string t1("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+    const u8 *t1_raw = (const u8 *)t1.c_str();
+
+    for (size_t i = 0; i < 16; i++) {
+        for (size_t j = 0; j < 16; j++) {
+            const u8 *rv = vermicelliDoubleMaskedExec('a', 'b', 0xff, 0xff,
+                                                  t1_raw + i,
+                                                  t1_raw + t1.length() - i - j);
+
+            ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j - 1), (size_t)rv);
+            rv = vermicelliDoubleMaskedExec('B', 'b', 0xff, CASE_CLEAR,
+                                            t1_raw + i,
+                                            t1_raw + t1.length() - i - j);
+
+            ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j  - 1), (size_t)rv);
+
+            rv = vermicelliDoubleMaskedExec('A', 'B', CASE_CLEAR, CASE_CLEAR,
+                                            t1_raw + i,
+                                            t1_raw + t1.length() -i - j);
+
+            ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j  - 1), (size_t)rv);
+
+            rv = vermicelliDoubleMaskedExec('b', 'B', CASE_CLEAR, 0xff,
+                                            t1_raw + i,
+                                            t1_raw + t1.length() - i - j);
+
+            ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j  - 1), (size_t)rv);
+
+            rv = vermicelliDoubleMaskedExec('B', 'A', 0xff, 0xff,
+                                            t1_raw + i,
+                                            t1_raw + t1.length() - i - j);
+
+            ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j - 1), (size_t)rv);
+        }
+    }
+}
+
+TEST(DoubleVermicelliMasked, Exec1) {
+    std::string t1("bbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbb");
+    const u8 *t1_raw = (const u8 *)t1.c_str();
+
+    for (size_t i = 0; i < 16; i++) {
+        const u8 *rv = vermicelliDoubleMaskedExec('a', 'b', 0xff, 0xff,
+                                                  t1_raw + i,
+                                                  t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('A', 'B', CASE_CLEAR, CASE_CLEAR,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('a', 'B', 0xff, CASE_CLEAR,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('A', 'b', CASE_CLEAR, 0xff,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('b', 'a', 0xff, 0xff,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('B', 'A', CASE_CLEAR, CASE_CLEAR,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv);
+    }
+}
+
+TEST(DoubleVermicelliMasked,  Exec2) {
+    std::string t1("bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbb");
+    const u8 *t1_raw = (const u8 *)t1.c_str();
+
+    for (size_t i = 0; i < 16; i++) {
+        const u8 *rv = vermicelliDoubleMaskedExec('a', 'a', 0xff, 0xff,
+                                                  t1_raw + i,
+                                                  t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('A', 'A', CASE_CLEAR, CASE_CLEAR,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('a', 'A', 0xff, CASE_CLEAR,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('A', 'a', CASE_CLEAR, 0xff,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv);
+}
+}
+
+TEST(DoubleVermicelliMasked,  Exec3) {
+    /*              012345678901234567890123 */
+    std::string t1("bbbbbbbbbbbbbbbbbaAaaAAaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbb");
+    const u8 *t1_raw = (const u8 *)t1.c_str();
+
+    for (size_t i = 0; i < 16; i++) {
+        const u8 *rv = vermicelliDoubleMaskedExec('A', 'a', 0xff, 0xff,
+                                                  t1_raw + i,
+                                                  t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('A', 'A', CASE_CLEAR, CASE_CLEAR,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('A', 'A', 0xff, 0xff,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 21, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('a', 'A', 0xff, 0xff,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('a', 'A', 0xff, CASE_CLEAR,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('A', 'a', CASE_CLEAR, 0xff,
+                                        t1_raw + i,
+                                        t1_raw + t1.length() - i);
+
+        ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv);
+}
+}
+
+TEST(DoubleVermicelliMasked, Exec4) {
+    std::string t1("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+    const u8 *t1_raw = (const u8 *)t1.c_str();
+
+    for (size_t i = 0; i < 31; i++) {
+        t1[48 - i] = 'a';
+        t1[48 - i + 1] = 'a';
+        const u8 *rv = vermicelliDoubleMaskedExec('a', 'a', 0xff, 0xff, t1_raw,
+                                                  t1_raw + t1.length());
+
+        ASSERT_EQ((size_t)&t1_raw[48 - i], (size_t)rv);
+
+        rv = vermicelliDoubleMaskedExec('A', 'A', CASE_CLEAR, CASE_CLEAR, t1_raw,
+                                        t1_raw + t1.length());
+
+        ASSERT_EQ((size_t)&t1_raw[48 - i], (size_t)rv);
+    }
+}
+
diff --git a/util/CMakeLists.txt b/util/CMakeLists.txt
index c664ec25..dc731322 100644
--- a/util/CMakeLists.txt
+++ b/util/CMakeLists.txt
@@ -16,7 +16,7 @@ set(expressionutil_SRCS
     ExpressionParser.h
     ExpressionParser.cpp
     )
-add_library(expressionutil ${expressionutil_SRCS})
+add_library(expressionutil STATIC ${expressionutil_SRCS})
 add_dependencies(expressionutil ragel_ExpressionParser)
 
 SET(corpusomatic_SRCS
@@ -29,5 +29,5 @@ SET(corpusomatic_SRCS
     ng_find_matches.h
     ng_find_matches.cpp
 )
-add_library(corpusomatic ${corpusomatic_SRCS})
+add_library(corpusomatic STATIC ${corpusomatic_SRCS})
 
diff --git a/util/ng_find_matches.cpp b/util/ng_find_matches.cpp
index d2456c8f..4d188d78 100644
--- a/util/ng_find_matches.cpp
+++ b/util/ng_find_matches.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -47,34 +47,59 @@
 using namespace std;
 using namespace ue2;
 
-// convenience typedefs
-typedef map<NFAVertex,size_t> SOMMap;
-typedef set<pair<size_t, size_t> > MatchSet;
+namespace {
+
+struct StateSet {
+    explicit StateSet(size_t sz) : s(sz), som(sz, 0) {}
+    boost::dynamic_bitset<> s; // bitset of states that are on
+    vector<size_t> som; // som value for each state
+};
+
+using MatchSet = set<pair<size_t, size_t>>;
 
 struct fmstate {
-    SOMMap states;
-    SOMMap next;
-    size_t offset;
-    unsigned char cur;
-    unsigned char prev;
+    const size_t num_states; // number of vertices in graph
+    StateSet states; // currently active states
+    StateSet next; // states on after this iteration
+    vector<NFAVertex> vertices; // mapping from index to vertex
+    size_t offset = 0;
+    unsigned char cur = 0;
+    unsigned char prev = 0;
     const bool som;
     const bool utf8;
     const bool allowStartDs;
     const ReportManager &rm;
 
-    fmstate(const bool som_in, const bool utf8_in, const bool aSD_in,
+    boost::dynamic_bitset<> accept; // states leading to accept
+    boost::dynamic_bitset<> accept_with_eod; // states leading to accept or eod
+
+    fmstate(const NGHolder &g, bool som_in, bool utf8_in, bool aSD_in,
             const ReportManager &rm_in)
-        : offset(0), cur(0), prev(0), som(som_in), utf8(utf8_in),
-          allowStartDs(aSD_in), rm(rm_in) {}
+        : num_states(num_vertices(g)), states(num_states), next(num_states),
+          vertices(num_vertices(g), NFAGraph::null_vertex()), som(som_in),
+          utf8(utf8_in), allowStartDs(aSD_in), rm(rm_in), accept(num_states),
+          accept_with_eod(num_states) {
+        // init states
+        states.s.set(g[g.start].index);
+        if (allowStartDs) {
+            states.s.set(g[g.startDs].index);
+        }
+        // fill vertex mapping
+        for (const auto &v : vertices_range(g)) {
+            vertices[g[v].index] = v;
+        }
+        // init accept states
+        for (const auto &u : inv_adjacent_vertices_range(g.accept, g)) {
+            accept.set(g[u].index);
+        }
+        accept_with_eod = accept;
+        for (const auto &u : inv_adjacent_vertices_range(g.acceptEod, g)) {
+            accept_with_eod.set(g[u].index);
+        }
+    }
 };
 
-static
-void initStates(const NGHolder &g, struct fmstate &state) {
-    state.states.insert(make_pair(g.start, 0));
-    if (state.allowStartDs) {
-        state.states.insert(make_pair(g.startDs, 0));
-    }
-}
+} // namespace
 
 static
 bool isWordChar(const unsigned char c) {
@@ -115,17 +140,9 @@ bool isUtf8CodePoint(const char c) {
 }
 
 static
-bool canReach(const NGHolder &g, const NFAVertex &src, const NFAVertex &dst,
+bool canReach(const NGHolder &g, const NFAEdge &e,
               struct fmstate &state) {
-    // find relevant edge and see whether it has asserts
-    NFAEdge e;
-    bool exists;
-    u32 flags;
-
-    tie(e, exists) = edge(src, dst, g);
-    assert(exists);
-
-    flags = g[e].assert_flags;
+    auto flags = g[e].assert_flags;
     if (!flags) {
         return true;
     }
@@ -160,33 +177,35 @@ bool canReach(const NGHolder &g, const NFAVertex &src, const NFAVertex &dst,
 static
 void getMatches(const NGHolder &g, MatchSet &matches, struct fmstate &state,
                 bool allowEodMatches) {
-    SOMMap::const_iterator it, ite;
+    auto acc_states = state.states.s;
+    acc_states &= allowEodMatches ? state.accept_with_eod : state.accept;
 
-    for (it = state.states.begin(), ite = state.states.end(); it != ite; ++it) {
-        NFAGraph::adjacency_iterator ai, ae;
+    for (size_t i = acc_states.find_first(); i != acc_states.npos;
+         i = acc_states.find_next(i)) {
+        const NFAVertex u = state.vertices[i];
+        const size_t &som_offset = state.states.som[i];
 
-        // we can't accept anything from startDs inbetween UTF-8 codepoints
-        if (state.utf8 && it->first == g.startDs && !isUtf8CodePoint(state.cur)) {
+        // we can't accept anything from startDs in between UTF-8 codepoints
+        if (state.utf8 && u == g.startDs && !isUtf8CodePoint(state.cur)) {
             continue;
         }
 
-        for (tie(ai, ae) = adjacent_vertices(it->first, g); ai != ae; ++ai) {
-            if (*ai == g.accept || (*ai == g.acceptEod && allowEodMatches)) {
+        for (const auto &e : out_edges_range(u, g)) {
+            NFAVertex v = target(e, g);
+            if (v == g.accept || (v == g.acceptEod && allowEodMatches)) {
                 // check edge assertions if we are allowed to reach accept
-                if (!canReach(g, it->first, *ai, state)) {
+                if (!canReach(g, e, state)) {
                     continue;
                 }
                 DEBUG_PRINTF("match found at %zu\n", state.offset);
 
-                assert(!g[it->first].reports.empty());
-                for (const auto &report_id :
-                     g[it->first].reports) {
+                assert(!g[u].reports.empty());
+                for (const auto &report_id : g[u].reports) {
                     const Report &ri = state.rm.getReport(report_id);
 
                     DEBUG_PRINTF("report %u has offset adjustment %d\n",
                                  report_id, ri.offsetAdjust);
-                    matches.insert(
-                        make_pair(it->second, state.offset + ri.offsetAdjust));
+                    matches.emplace(som_offset, state.offset + ri.offsetAdjust);
                 }
             }
         }
@@ -195,55 +214,57 @@ void getMatches(const NGHolder &g, MatchSet &matches, struct fmstate &state,
 
 static
 void step(const NGHolder &g, struct fmstate &state) {
-    state.next.clear();
-    SOMMap::iterator it, ite;
+    state.next.s.reset();
 
-    for (it = state.states.begin(), ite = state.states.end(); it != ite; ++it) {
-        NFAGraph::adjacency_iterator ai, ae;
+    for (size_t i = state.states.s.find_first(); i != state.states.s.npos;
+         i = state.states.s.find_next(i)) {
+        const NFAVertex &u = state.vertices[i];
+        const size_t &u_som_offset = state.states.som[i];
 
-        for (tie(ai, ae) = adjacent_vertices(it->first, g); ai != ae; ++ai) {
-            if (*ai == g.acceptEod) {
+        for (const auto &e : out_edges_range(u, g)) {
+            NFAVertex v = target(e, g);
+            if (v == g.acceptEod) {
                 // can't know the future: we don't know if we're at EOD.
                 continue;
             }
-            if (*ai == g.accept) {
+            if (v == g.accept) {
                 continue;
             }
 
-            if (!state.allowStartDs && *ai == g.startDs) {
+            if (!state.allowStartDs && v == g.startDs) {
                 continue;
             }
 
-            const CharReach &cr = g[*ai].char_reach;
+            const CharReach &cr = g[v].char_reach;
+            const size_t v_idx = g[v].index;
+
             // check reachability and edge assertions
-            if (cr.test(state.cur) && canReach(g, it->first, *ai, state)) {
-                SOMMap::const_iterator ni;
-                size_t next_som;
-
+            if (cr.test(state.cur) && canReach(g, e, state)) {
                 // if we aren't in SOM mode, just set every SOM to 0
                 if (!state.som) {
-                    state.next[*ai] = 0;
+                    state.next.s.set(v_idx);
+                    state.next.som[v_idx] = 0;
                     continue;
                 }
 
                 // if this is first vertex since start, use current offset as SOM
-                if (it->first == g.start || it->first == g.startDs ||
-                        is_virtual_start(it->first, g)) {
+                size_t next_som;
+                if (u == g.start || u == g.startDs || is_virtual_start(u, g)) {
                     next_som = state.offset;
                 } else {
                     // else, inherit SOM from predecessor
-                    next_som = it->second;
+                    next_som = u_som_offset;
                 }
 
                 // check if the vertex is already active
-                ni = state.next.find(*ai);
-
                 // if this vertex is not yet active, use current SOM
-                if (ni == state.next.end()) {
-                    state.next[*ai] = next_som;
+                if (!state.next.s.test(v_idx)) {
+                    state.next.s.set(v_idx);
+                    state.next.som[v_idx] = next_som;
                 } else {
                     // else, work out leftmost SOM
-                    state.next[*ai] = min(next_som, ni->second);
+                    state.next.som[v_idx] =
+                        min(next_som, state.next.som[v_idx]);
                 }
             }
         }
@@ -251,34 +272,32 @@ void step(const NGHolder &g, struct fmstate &state) {
 }
 
 // filter extraneous matches
-static void filterMatches(MatchSet &matches) {
+static
+void filterMatches(MatchSet &matches) {
     set<size_t> eom;
-    MatchSet::iterator msit;
 
     // first, collect all end-offset matches
-    for (msit = matches.begin(); msit != matches.end(); ++msit) {
-        eom.insert(msit->second);
+    for (const auto &match : matches) {
+        eom.insert(match.second);
     }
 
     // now, go through all the end-offsets and filter extra matches
-    set<size_t>::const_iterator eomit;
-    for (eomit = eom.begin(); eomit != eom.end(); ++eomit) {
-
+    for (const auto &elem : eom) {
         // find minimum SOM for this EOM
         size_t min_som = -1U;
-        for (msit = matches.begin(); msit != matches.end(); ++msit) {
+        for (const auto &match : matches) {
             // skip entries with wrong EOM
-            if (msit->second != *eomit) {
+            if (match.second != elem) {
                 continue;
             }
 
-            min_som = min(min_som, msit->first);
+            min_som = min(min_som, match.first);
         }
 
-        msit = matches.begin();
+        auto msit = matches.begin();
         while (msit != matches.end()) {
             // skip everything that doesn't match
-            if (msit->second != *eomit || msit->first <= min_som) {
+            if (msit->second != elem || msit->first <= min_som) {
                 ++msit;
                 continue;
             }
@@ -295,14 +314,13 @@ static void filterMatches(MatchSet &matches) {
 void findMatches(const NGHolder &g, const ReportManager &rm,
                  const string &input, MatchSet &matches, const bool notEod,
                  const bool som, const bool utf8) {
+    assert(hasCorrectlyNumberedVertices(g));
+
     const bool allowStartDs = (proper_out_degree(g.startDs, g) > 0);
 
-    struct fmstate state(som, utf8, allowStartDs, rm);
+    struct fmstate state(g, som, utf8, allowStartDs, rm);
 
-    initStates(g, state);
-
-    string::const_iterator it, ite;
-    for (it = input.begin(), ite = input.end(); it != ite; ++it) {
+    for (auto it = input.begin(), ite = input.end(); it != ite; ++it) {
         state.offset = distance(input.begin(), it);
         state.cur = *it;
 
@@ -310,14 +328,15 @@ void findMatches(const NGHolder &g, const ReportManager &rm,
 
         getMatches(g, matches, state, false);
 
-        DEBUG_PRINTF("index %zu, %zu states on\n", state.offset, state.next.size());
-        if (state.next.empty()) {
+        DEBUG_PRINTF("index %zu, %zu states on\n", state.offset,
+                     state.next.s.count());
+        if (state.next.s.empty()) {
             if (state.som) {
                 filterMatches(matches);
             }
             return;
         }
-        state.states.swap(state.next);
+        state.states = state.next;
         state.prev = state.cur;
     }
     state.offset = input.size();