Restoring authorship annotation for Ivan Blinkov <ivan@blinkov.ru>. Commit 2 of 2.

1 files changed, 646 insertions, 646 deletions

diff --git a/contrib/libs/hyperscan/src/rose/rose_build_instructions.cpp b/contrib/libs/hyperscan/src/rose/rose_build_instructions.cpp
index 3dbbe747c2..f96221b247 100644
--- a/contrib/libs/hyperscan/src/rose/rose_build_instructions.cpp
+++ b/contrib/libs/hyperscan/src/rose/rose_build_instructions.cpp
@@ -1,167 +1,167 @@
-/* 
+/*
  * Copyright (c) 2017-2020, 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_instructions.h" 
- 
-#include "rose_build_engine_blob.h" 
-#include "util/multibit_build.h" 
-#include "util/verify_types.h" 
- 
-#include <algorithm> 
- 
-using namespace std; 
- 
-namespace ue2 { 
-/* Destructors to avoid weak vtables. */ 
- 
-RoseInstruction::~RoseInstruction() = default; 
-RoseInstrCatchUp::~RoseInstrCatchUp() = default; 
-RoseInstrCatchUpMpv::~RoseInstrCatchUpMpv() = default; 
-RoseInstrSomZero::~RoseInstrSomZero() = default; 
-RoseInstrSuffixesEod::~RoseInstrSuffixesEod() = default; 
-RoseInstrMatcherEod::~RoseInstrMatcherEod() = default; 
-RoseInstrEnd::~RoseInstrEnd() = default; 
-RoseInstrClearWorkDone::~RoseInstrClearWorkDone() = default; 
+ *
+ * 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_instructions.h"
+
+#include "rose_build_engine_blob.h"
+#include "util/multibit_build.h"
+#include "util/verify_types.h"
+
+#include <algorithm>
+
+using namespace std;
+
+namespace ue2 {
+/* Destructors to avoid weak vtables. */
+
+RoseInstruction::~RoseInstruction() = default;
+RoseInstrCatchUp::~RoseInstrCatchUp() = default;
+RoseInstrCatchUpMpv::~RoseInstrCatchUpMpv() = default;
+RoseInstrSomZero::~RoseInstrSomZero() = default;
+RoseInstrSuffixesEod::~RoseInstrSuffixesEod() = default;
+RoseInstrMatcherEod::~RoseInstrMatcherEod() = default;
+RoseInstrEnd::~RoseInstrEnd() = default;
+RoseInstrClearWorkDone::~RoseInstrClearWorkDone() = default;
 RoseInstrFlushCombination::~RoseInstrFlushCombination() = default;
 RoseInstrLastFlushCombination::~RoseInstrLastFlushCombination() = default;
- 
-using OffsetMap = RoseInstruction::OffsetMap; 
- 
-static 
-u32 calc_jump(const OffsetMap &offset_map, const RoseInstruction *from, 
-              const RoseInstruction *to) { 
-    DEBUG_PRINTF("computing relative jump from %p to %p\n", from, to); 
-    assert(from && contains(offset_map, from)); 
-    assert(to && contains(offset_map, to)); 
- 
-    u32 from_offset = offset_map.at(from); 
-    u32 to_offset = offset_map.at(to); 
-    DEBUG_PRINTF("offsets: %u -> %u\n", from_offset, to_offset); 
-    assert(from_offset <= to_offset); 
- 
-    return to_offset - from_offset; 
-} 
- 
-void RoseInstrAnchoredDelay::write(void *dest, RoseEngineBlob &blob, 
-                                   const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->groups = groups; 
-    inst->anch_id = anch_id; 
-    inst->done_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckLitEarly::write(void *dest, RoseEngineBlob &blob, 
-                                   const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->min_offset = min_offset; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckGroups::write(void *dest, RoseEngineBlob &blob, 
-                                 const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->groups = groups; 
-} 
- 
-void RoseInstrCheckOnlyEod::write(void *dest, RoseEngineBlob &blob, 
-                                  const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckBounds::write(void *dest, RoseEngineBlob &blob, 
-                                 const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->min_bound = min_bound; 
-    inst->max_bound = max_bound; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckNotHandled::write(void *dest, RoseEngineBlob &blob, 
-                                     const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->key = key; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckSingleLookaround::write(void *dest, RoseEngineBlob &blob, 
-                                           const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->offset = offset; 
-    inst->reach_index = blob.lookaround_cache.get_offset_of({reach}, blob); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckLookaround::write(void *dest, RoseEngineBlob &blob, 
-                                     const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    vector<s8> look_offsets; 
-    vector<CharReach> reaches; 
-    for (const auto &le : look) { 
-        look_offsets.push_back(le.offset); 
-        reaches.push_back(le.reach); 
-    } 
-    inst->look_index = blob.lookaround_cache.get_offset_of(look_offsets, blob); 
-    inst->reach_index = blob.lookaround_cache.get_offset_of(reaches, blob); 
-    inst->count = verify_u32(look.size()); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckMask::write(void *dest, RoseEngineBlob &blob, 
-                               const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->and_mask = and_mask; 
-    inst->cmp_mask = cmp_mask; 
-    inst->neg_mask = neg_mask; 
-    inst->offset = offset; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckMask32::write(void *dest, RoseEngineBlob &blob, 
-                                 const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    copy(begin(and_mask), end(and_mask), inst->and_mask); 
-    copy(begin(cmp_mask), end(cmp_mask), inst->cmp_mask); 
-    inst->neg_mask = neg_mask; 
-    inst->offset = offset; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
+
+using OffsetMap = RoseInstruction::OffsetMap;
+
+static
+u32 calc_jump(const OffsetMap &offset_map, const RoseInstruction *from,
+              const RoseInstruction *to) {
+    DEBUG_PRINTF("computing relative jump from %p to %p\n", from, to);
+    assert(from && contains(offset_map, from));
+    assert(to && contains(offset_map, to));
+
+    u32 from_offset = offset_map.at(from);
+    u32 to_offset = offset_map.at(to);
+    DEBUG_PRINTF("offsets: %u -> %u\n", from_offset, to_offset);
+    assert(from_offset <= to_offset);
+
+    return to_offset - from_offset;
+}
+
+void RoseInstrAnchoredDelay::write(void *dest, RoseEngineBlob &blob,
+                                   const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->groups = groups;
+    inst->anch_id = anch_id;
+    inst->done_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckLitEarly::write(void *dest, RoseEngineBlob &blob,
+                                   const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->min_offset = min_offset;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckGroups::write(void *dest, RoseEngineBlob &blob,
+                                 const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->groups = groups;
+}
+
+void RoseInstrCheckOnlyEod::write(void *dest, RoseEngineBlob &blob,
+                                  const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckBounds::write(void *dest, RoseEngineBlob &blob,
+                                 const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->min_bound = min_bound;
+    inst->max_bound = max_bound;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckNotHandled::write(void *dest, RoseEngineBlob &blob,
+                                     const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->key = key;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckSingleLookaround::write(void *dest, RoseEngineBlob &blob,
+                                           const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->offset = offset;
+    inst->reach_index = blob.lookaround_cache.get_offset_of({reach}, blob);
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckLookaround::write(void *dest, RoseEngineBlob &blob,
+                                     const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    vector<s8> look_offsets;
+    vector<CharReach> reaches;
+    for (const auto &le : look) {
+        look_offsets.push_back(le.offset);
+        reaches.push_back(le.reach);
+    }
+    inst->look_index = blob.lookaround_cache.get_offset_of(look_offsets, blob);
+    inst->reach_index = blob.lookaround_cache.get_offset_of(reaches, blob);
+    inst->count = verify_u32(look.size());
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckMask::write(void *dest, RoseEngineBlob &blob,
+                               const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->and_mask = and_mask;
+    inst->cmp_mask = cmp_mask;
+    inst->neg_mask = neg_mask;
+    inst->offset = offset;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckMask32::write(void *dest, RoseEngineBlob &blob,
+                                 const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    copy(begin(and_mask), end(and_mask), inst->and_mask);
+    copy(begin(cmp_mask), end(cmp_mask), inst->cmp_mask);
+    inst->neg_mask = neg_mask;
+    inst->offset = offset;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
 void RoseInstrCheckMask64::write(void *dest, RoseEngineBlob &blob,
                                  const OffsetMap &offset_map) const {
     RoseInstrBase::write(dest, blob, offset_map);
@@ -173,71 +173,71 @@ void RoseInstrCheckMask64::write(void *dest, RoseEngineBlob &blob,
     inst->fail_jump = calc_jump(offset_map, this, target);
 }
 
-void RoseInstrCheckByte::write(void *dest, RoseEngineBlob &blob, 
-                               const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->and_mask = and_mask; 
-    inst->cmp_mask = cmp_mask; 
-    inst->negation = negation; 
-    inst->offset = offset; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckShufti16x8::write(void *dest, RoseEngineBlob &blob, 
-                                     const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    copy(begin(nib_mask), end(nib_mask), inst->nib_mask); 
-    copy(begin(bucket_select_mask), end(bucket_select_mask), 
-         inst->bucket_select_mask); 
-    inst->neg_mask = neg_mask; 
-    inst->offset = offset; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckShufti32x8::write(void *dest, RoseEngineBlob &blob, 
-                                     const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    copy(begin(hi_mask), end(hi_mask), inst->hi_mask); 
-    copy(begin(lo_mask), end(lo_mask), inst->lo_mask); 
-    copy(begin(bucket_select_mask), end(bucket_select_mask), 
-         inst->bucket_select_mask); 
- 
-    inst->neg_mask = neg_mask; 
-    inst->offset = offset; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckShufti16x16::write(void *dest, RoseEngineBlob &blob, 
-                                      const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    copy(begin(hi_mask), end(hi_mask), inst->hi_mask); 
-    copy(begin(lo_mask), end(lo_mask), inst->lo_mask); 
-    copy(begin(bucket_select_mask), end(bucket_select_mask), 
-         inst->bucket_select_mask); 
-    inst->neg_mask = neg_mask; 
-    inst->offset = offset; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckShufti32x16::write(void *dest, RoseEngineBlob &blob, 
-                                      const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    copy(begin(hi_mask), end(hi_mask), inst->hi_mask); 
-    copy(begin(lo_mask), end(lo_mask), inst->lo_mask); 
-    copy(begin(bucket_select_mask_hi), end(bucket_select_mask_hi), 
-         inst->bucket_select_mask_hi); 
-    copy(begin(bucket_select_mask_lo), end(bucket_select_mask_lo), 
-         inst->bucket_select_mask_lo); 
-    inst->neg_mask = neg_mask; 
-    inst->offset = offset; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
+void RoseInstrCheckByte::write(void *dest, RoseEngineBlob &blob,
+                               const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->and_mask = and_mask;
+    inst->cmp_mask = cmp_mask;
+    inst->negation = negation;
+    inst->offset = offset;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckShufti16x8::write(void *dest, RoseEngineBlob &blob,
+                                     const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    copy(begin(nib_mask), end(nib_mask), inst->nib_mask);
+    copy(begin(bucket_select_mask), end(bucket_select_mask),
+         inst->bucket_select_mask);
+    inst->neg_mask = neg_mask;
+    inst->offset = offset;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckShufti32x8::write(void *dest, RoseEngineBlob &blob,
+                                     const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    copy(begin(hi_mask), end(hi_mask), inst->hi_mask);
+    copy(begin(lo_mask), end(lo_mask), inst->lo_mask);
+    copy(begin(bucket_select_mask), end(bucket_select_mask),
+         inst->bucket_select_mask);
+
+    inst->neg_mask = neg_mask;
+    inst->offset = offset;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckShufti16x16::write(void *dest, RoseEngineBlob &blob,
+                                      const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    copy(begin(hi_mask), end(hi_mask), inst->hi_mask);
+    copy(begin(lo_mask), end(lo_mask), inst->lo_mask);
+    copy(begin(bucket_select_mask), end(bucket_select_mask),
+         inst->bucket_select_mask);
+    inst->neg_mask = neg_mask;
+    inst->offset = offset;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckShufti32x16::write(void *dest, RoseEngineBlob &blob,
+                                      const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    copy(begin(hi_mask), end(hi_mask), inst->hi_mask);
+    copy(begin(lo_mask), end(lo_mask), inst->lo_mask);
+    copy(begin(bucket_select_mask_hi), end(bucket_select_mask_hi),
+         inst->bucket_select_mask_hi);
+    copy(begin(bucket_select_mask_lo), end(bucket_select_mask_lo),
+         inst->bucket_select_mask_lo);
+    inst->neg_mask = neg_mask;
+    inst->offset = offset;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
 void RoseInstrCheckShufti64x8::write(void *dest, RoseEngineBlob &blob,
                                      const OffsetMap &offset_map) const {
     RoseInstrBase::write(dest, blob, offset_map);
@@ -268,432 +268,432 @@ void RoseInstrCheckShufti64x16::write(void *dest, RoseEngineBlob &blob,
     inst->fail_jump = calc_jump(offset_map, this, target);
 }
 
-void RoseInstrCheckInfix::write(void *dest, RoseEngineBlob &blob, 
-                                const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->queue = queue; 
-    inst->lag = lag; 
-    inst->report = report; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckPrefix::write(void *dest, RoseEngineBlob &blob, 
-                                 const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->queue = queue; 
-    inst->lag = lag; 
-    inst->report = report; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrPushDelayed::write(void *dest, RoseEngineBlob &blob, 
-                                 const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->delay = delay; 
-    inst->index = index; 
-} 
- 
-void RoseInstrSomAdjust::write(void *dest, RoseEngineBlob &blob, 
-                               const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->distance = distance; 
-} 
- 
-void RoseInstrSomLeftfix::write(void *dest, RoseEngineBlob &blob, 
-                                const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->queue = queue; 
-    inst->lag = lag; 
-} 
- 
-void RoseInstrSomFromReport::write(void *dest, RoseEngineBlob &blob, 
-                                   const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->som = som; 
-} 
- 
-void RoseInstrTriggerInfix::write(void *dest, RoseEngineBlob &blob, 
-                                  const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->cancel = cancel; 
-    inst->queue = queue; 
-    inst->event = event; 
-} 
- 
-void RoseInstrTriggerSuffix::write(void *dest, RoseEngineBlob &blob, 
-                                   const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->queue = queue; 
-    inst->event = event; 
-} 
- 
-void RoseInstrDedupe::write(void *dest, RoseEngineBlob &blob, 
-                            const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->quash_som = quash_som; 
-    inst->dkey = dkey; 
-    inst->offset_adjust = offset_adjust; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrDedupeSom::write(void *dest, RoseEngineBlob &blob, 
-                               const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->quash_som = quash_som; 
-    inst->dkey = dkey; 
-    inst->offset_adjust = offset_adjust; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrReportChain::write(void *dest, RoseEngineBlob &blob, 
-                                 const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->event = event; 
-    inst->top_squash_distance = top_squash_distance; 
-} 
- 
-void RoseInstrReportSomInt::write(void *dest, RoseEngineBlob &blob, 
-                                  const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->som = som; 
-} 
- 
-void RoseInstrReportSomAware::write(void *dest, RoseEngineBlob &blob, 
-                                    const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->som = som; 
-} 
- 
-void RoseInstrReport::write(void *dest, RoseEngineBlob &blob, 
-                            const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->onmatch = onmatch; 
-    inst->offset_adjust = offset_adjust; 
-} 
- 
-void RoseInstrReportExhaust::write(void *dest, RoseEngineBlob &blob, 
-                                   const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->onmatch = onmatch; 
-    inst->offset_adjust = offset_adjust; 
-    inst->ekey = ekey; 
-} 
- 
-void RoseInstrReportSom::write(void *dest, RoseEngineBlob &blob, 
-                               const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->onmatch = onmatch; 
-    inst->offset_adjust = offset_adjust; 
-} 
- 
-void RoseInstrReportSomExhaust::write(void *dest, RoseEngineBlob &blob, 
-                                      const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->onmatch = onmatch; 
-    inst->offset_adjust = offset_adjust; 
-    inst->ekey = ekey; 
-} 
- 
-void RoseInstrDedupeAndReport::write(void *dest, RoseEngineBlob &blob, 
-                                     const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->quash_som = quash_som; 
-    inst->dkey = dkey; 
-    inst->onmatch = onmatch; 
-    inst->offset_adjust = offset_adjust; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrFinalReport::write(void *dest, RoseEngineBlob &blob, 
-                                 const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->onmatch = onmatch; 
-    inst->offset_adjust = offset_adjust; 
-} 
- 
-void RoseInstrCheckExhausted::write(void *dest, RoseEngineBlob &blob, 
-                                    const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->ekey = ekey; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckMinLength::write(void *dest, RoseEngineBlob &blob, 
-                                    const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->end_adj = end_adj; 
-    inst->min_length = min_length; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrSetState::write(void *dest, RoseEngineBlob &blob, 
-                              const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->index = index; 
-} 
- 
-void RoseInstrSetGroups::write(void *dest, RoseEngineBlob &blob, 
-                              const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->groups = groups; 
-} 
- 
-void RoseInstrSquashGroups::write(void *dest, RoseEngineBlob &blob, 
-                                  const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->groups = groups; 
-} 
- 
-void RoseInstrCheckState::write(void *dest, RoseEngineBlob &blob, 
-                                const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->index = index; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrSparseIterBegin::write(void *dest, RoseEngineBlob &blob, 
-                                     const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
- 
-    // Resolve and write the multibit sparse iterator and the jump table. 
-    vector<u32> keys; 
-    vector<u32> jump_offsets; 
-    for (const auto &jump : jump_table) { 
-        keys.push_back(jump.first); 
-        assert(contains(offset_map, jump.second)); 
-        jump_offsets.push_back(offset_map.at(jump.second)); 
-    } 
- 
-    auto iter = mmbBuildSparseIterator(keys, num_keys); 
-    assert(!iter.empty()); 
-    inst->iter_offset = blob.add_iterator(iter); 
-    inst->jump_table = blob.add(jump_offsets.begin(), jump_offsets.end()); 
- 
-    // Store offsets for corresponding SPARSE_ITER_NEXT operations. 
-    is_written = true; 
-    iter_offset = inst->iter_offset; 
-    jump_table_offset = inst->jump_table; 
-} 
- 
-void RoseInstrSparseIterNext::write(void *dest, RoseEngineBlob &blob, 
-                                    const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->state = state; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
- 
-    // Use the same sparse iterator and jump table as the SPARSE_ITER_BEGIN 
-    // instruction. 
-    assert(begin); 
-    assert(contains(offset_map, begin)); 
-    assert(begin->is_written); 
-    inst->iter_offset = begin->iter_offset; 
-    inst->jump_table = begin->jump_table_offset; 
-} 
- 
-void RoseInstrSparseIterAny::write(void *dest, RoseEngineBlob &blob, 
-                                   const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
- 
-    // Write the multibit sparse iterator. 
-    auto iter = mmbBuildSparseIterator(keys, num_keys); 
-    assert(!iter.empty()); 
-    inst->iter_offset = blob.add_iterator(iter); 
-} 
- 
-void RoseInstrEnginesEod::write(void *dest, RoseEngineBlob &blob, 
-                                const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->iter_offset = iter_offset; 
-} 
- 
-void RoseInstrCheckLongLit::write(void *dest, RoseEngineBlob &blob, 
-                                  const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    assert(!literal.empty()); 
-    inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1); 
-    inst->lit_length = verify_u32(literal.size()); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckLongLitNocase::write(void *dest, RoseEngineBlob &blob, 
-                                        const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    assert(!literal.empty()); 
-    inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1); 
-    inst->lit_length = verify_u32(literal.size()); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckMedLit::write(void *dest, RoseEngineBlob &blob, 
-                                 const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    assert(!literal.empty()); 
-    inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1); 
-    inst->lit_length = verify_u32(literal.size()); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckMedLitNocase::write(void *dest, RoseEngineBlob &blob, 
-                                       const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    assert(!literal.empty()); 
-    inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1); 
-    inst->lit_length = verify_u32(literal.size()); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrMultipathLookaround::write(void *dest, RoseEngineBlob &blob, 
-                                         const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    auto &cache = blob.lookaround_cache; 
-    vector<s8> look_offsets; 
-    vector<vector<CharReach>> reaches; 
-    for (const auto &vle : multi_look) { 
-        reaches.push_back({}); 
-        bool done_offset = false; 
- 
-        for (const auto &le : vle) { 
-            reaches.back().push_back(le.reach); 
- 
-            /* empty reaches don't have valid offsets */ 
-            if (!done_offset && le.reach.any()) { 
-                look_offsets.push_back(le.offset); 
-                done_offset = true; 
-            } 
-        } 
-    } 
-    inst->look_index = cache.get_offset_of(look_offsets, blob); 
-    inst->reach_index = cache.get_offset_of(reaches, blob); 
-    inst->count = verify_u32(multi_look.size()); 
-    inst->last_start = last_start; 
-    copy(begin(start_mask), end(start_mask), inst->start_mask); 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckMultipathShufti16x8::write(void *dest, RoseEngineBlob &blob, 
-                                          const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    copy(begin(nib_mask), end(nib_mask), inst->nib_mask); 
-    copy(begin(bucket_select_mask), begin(bucket_select_mask) + 16, 
-         inst->bucket_select_mask); 
-    copy(begin(data_select_mask), begin(data_select_mask) + 16, 
-         inst->data_select_mask); 
-    inst->hi_bits_mask = hi_bits_mask; 
-    inst->lo_bits_mask = lo_bits_mask; 
-    inst->neg_mask = neg_mask; 
-    inst->base_offset = base_offset; 
-    inst->last_start = last_start; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckMultipathShufti32x8::write(void *dest, RoseEngineBlob &blob, 
-                                          const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    copy(begin(hi_mask), begin(hi_mask) + 16, inst->hi_mask); 
-    copy(begin(lo_mask), begin(lo_mask) + 16, inst->lo_mask); 
-    copy(begin(bucket_select_mask), begin(bucket_select_mask) + 32, 
-         inst->bucket_select_mask); 
-    copy(begin(data_select_mask), begin(data_select_mask) + 32, 
-         inst->data_select_mask); 
-    inst->hi_bits_mask = hi_bits_mask; 
-    inst->lo_bits_mask = lo_bits_mask; 
-    inst->neg_mask = neg_mask; 
-    inst->base_offset = base_offset; 
-    inst->last_start = last_start; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckMultipathShufti32x16::write(void *dest, RoseEngineBlob &blob, 
-                                           const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    copy(begin(hi_mask), end(hi_mask), inst->hi_mask); 
-    copy(begin(lo_mask), end(lo_mask), inst->lo_mask); 
-    copy(begin(bucket_select_mask_hi), begin(bucket_select_mask_hi) + 32, 
-         inst->bucket_select_mask_hi); 
-    copy(begin(bucket_select_mask_lo), begin(bucket_select_mask_lo) + 32, 
-         inst->bucket_select_mask_lo); 
-    copy(begin(data_select_mask), begin(data_select_mask) + 32, 
-         inst->data_select_mask); 
-    inst->hi_bits_mask = hi_bits_mask; 
-    inst->lo_bits_mask = lo_bits_mask; 
-    inst->neg_mask = neg_mask; 
-    inst->base_offset = base_offset; 
-    inst->last_start = last_start; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrCheckMultipathShufti64::write(void *dest, RoseEngineBlob &blob, 
-                                            const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    copy(begin(hi_mask), begin(hi_mask) + 16, inst->hi_mask); 
-    copy(begin(lo_mask), begin(lo_mask) + 16, inst->lo_mask); 
-    copy(begin(bucket_select_mask), end(bucket_select_mask), 
-         inst->bucket_select_mask); 
-    copy(begin(data_select_mask), end(data_select_mask), 
-         inst->data_select_mask); 
-    inst->hi_bits_mask = hi_bits_mask; 
-    inst->lo_bits_mask = lo_bits_mask; 
-    inst->neg_mask = neg_mask; 
-    inst->base_offset = base_offset; 
-    inst->last_start = last_start; 
-    inst->fail_jump = calc_jump(offset_map, this, target); 
-} 
- 
-void RoseInstrIncludedJump::write(void *dest, RoseEngineBlob &blob, 
-                                  const OffsetMap &offset_map) const { 
-    RoseInstrBase::write(dest, blob, offset_map); 
-    auto *inst = static_cast<impl_type *>(dest); 
-    inst->child_offset = child_offset; 
-    inst->squash = squash; 
-} 
- 
+void RoseInstrCheckInfix::write(void *dest, RoseEngineBlob &blob,
+                                const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->queue = queue;
+    inst->lag = lag;
+    inst->report = report;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckPrefix::write(void *dest, RoseEngineBlob &blob,
+                                 const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->queue = queue;
+    inst->lag = lag;
+    inst->report = report;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrPushDelayed::write(void *dest, RoseEngineBlob &blob,
+                                 const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->delay = delay;
+    inst->index = index;
+}
+
+void RoseInstrSomAdjust::write(void *dest, RoseEngineBlob &blob,
+                               const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->distance = distance;
+}
+
+void RoseInstrSomLeftfix::write(void *dest, RoseEngineBlob &blob,
+                                const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->queue = queue;
+    inst->lag = lag;
+}
+
+void RoseInstrSomFromReport::write(void *dest, RoseEngineBlob &blob,
+                                   const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->som = som;
+}
+
+void RoseInstrTriggerInfix::write(void *dest, RoseEngineBlob &blob,
+                                  const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->cancel = cancel;
+    inst->queue = queue;
+    inst->event = event;
+}
+
+void RoseInstrTriggerSuffix::write(void *dest, RoseEngineBlob &blob,
+                                   const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->queue = queue;
+    inst->event = event;
+}
+
+void RoseInstrDedupe::write(void *dest, RoseEngineBlob &blob,
+                            const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->quash_som = quash_som;
+    inst->dkey = dkey;
+    inst->offset_adjust = offset_adjust;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrDedupeSom::write(void *dest, RoseEngineBlob &blob,
+                               const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->quash_som = quash_som;
+    inst->dkey = dkey;
+    inst->offset_adjust = offset_adjust;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrReportChain::write(void *dest, RoseEngineBlob &blob,
+                                 const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->event = event;
+    inst->top_squash_distance = top_squash_distance;
+}
+
+void RoseInstrReportSomInt::write(void *dest, RoseEngineBlob &blob,
+                                  const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->som = som;
+}
+
+void RoseInstrReportSomAware::write(void *dest, RoseEngineBlob &blob,
+                                    const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->som = som;
+}
+
+void RoseInstrReport::write(void *dest, RoseEngineBlob &blob,
+                            const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->onmatch = onmatch;
+    inst->offset_adjust = offset_adjust;
+}
+
+void RoseInstrReportExhaust::write(void *dest, RoseEngineBlob &blob,
+                                   const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->onmatch = onmatch;
+    inst->offset_adjust = offset_adjust;
+    inst->ekey = ekey;
+}
+
+void RoseInstrReportSom::write(void *dest, RoseEngineBlob &blob,
+                               const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->onmatch = onmatch;
+    inst->offset_adjust = offset_adjust;
+}
+
+void RoseInstrReportSomExhaust::write(void *dest, RoseEngineBlob &blob,
+                                      const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->onmatch = onmatch;
+    inst->offset_adjust = offset_adjust;
+    inst->ekey = ekey;
+}
+
+void RoseInstrDedupeAndReport::write(void *dest, RoseEngineBlob &blob,
+                                     const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->quash_som = quash_som;
+    inst->dkey = dkey;
+    inst->onmatch = onmatch;
+    inst->offset_adjust = offset_adjust;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrFinalReport::write(void *dest, RoseEngineBlob &blob,
+                                 const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->onmatch = onmatch;
+    inst->offset_adjust = offset_adjust;
+}
+
+void RoseInstrCheckExhausted::write(void *dest, RoseEngineBlob &blob,
+                                    const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->ekey = ekey;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckMinLength::write(void *dest, RoseEngineBlob &blob,
+                                    const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->end_adj = end_adj;
+    inst->min_length = min_length;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrSetState::write(void *dest, RoseEngineBlob &blob,
+                              const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->index = index;
+}
+
+void RoseInstrSetGroups::write(void *dest, RoseEngineBlob &blob,
+                              const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->groups = groups;
+}
+
+void RoseInstrSquashGroups::write(void *dest, RoseEngineBlob &blob,
+                                  const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->groups = groups;
+}
+
+void RoseInstrCheckState::write(void *dest, RoseEngineBlob &blob,
+                                const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->index = index;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrSparseIterBegin::write(void *dest, RoseEngineBlob &blob,
+                                     const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->fail_jump = calc_jump(offset_map, this, target);
+
+    // Resolve and write the multibit sparse iterator and the jump table.
+    vector<u32> keys;
+    vector<u32> jump_offsets;
+    for (const auto &jump : jump_table) {
+        keys.push_back(jump.first);
+        assert(contains(offset_map, jump.second));
+        jump_offsets.push_back(offset_map.at(jump.second));
+    }
+
+    auto iter = mmbBuildSparseIterator(keys, num_keys);
+    assert(!iter.empty());
+    inst->iter_offset = blob.add_iterator(iter);
+    inst->jump_table = blob.add(jump_offsets.begin(), jump_offsets.end());
+
+    // Store offsets for corresponding SPARSE_ITER_NEXT operations.
+    is_written = true;
+    iter_offset = inst->iter_offset;
+    jump_table_offset = inst->jump_table;
+}
+
+void RoseInstrSparseIterNext::write(void *dest, RoseEngineBlob &blob,
+                                    const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->state = state;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+
+    // Use the same sparse iterator and jump table as the SPARSE_ITER_BEGIN
+    // instruction.
+    assert(begin);
+    assert(contains(offset_map, begin));
+    assert(begin->is_written);
+    inst->iter_offset = begin->iter_offset;
+    inst->jump_table = begin->jump_table_offset;
+}
+
+void RoseInstrSparseIterAny::write(void *dest, RoseEngineBlob &blob,
+                                   const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->fail_jump = calc_jump(offset_map, this, target);
+
+    // Write the multibit sparse iterator.
+    auto iter = mmbBuildSparseIterator(keys, num_keys);
+    assert(!iter.empty());
+    inst->iter_offset = blob.add_iterator(iter);
+}
+
+void RoseInstrEnginesEod::write(void *dest, RoseEngineBlob &blob,
+                                const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->iter_offset = iter_offset;
+}
+
+void RoseInstrCheckLongLit::write(void *dest, RoseEngineBlob &blob,
+                                  const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    assert(!literal.empty());
+    inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1);
+    inst->lit_length = verify_u32(literal.size());
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckLongLitNocase::write(void *dest, RoseEngineBlob &blob,
+                                        const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    assert(!literal.empty());
+    inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1);
+    inst->lit_length = verify_u32(literal.size());
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckMedLit::write(void *dest, RoseEngineBlob &blob,
+                                 const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    assert(!literal.empty());
+    inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1);
+    inst->lit_length = verify_u32(literal.size());
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckMedLitNocase::write(void *dest, RoseEngineBlob &blob,
+                                       const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    assert(!literal.empty());
+    inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1);
+    inst->lit_length = verify_u32(literal.size());
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrMultipathLookaround::write(void *dest, RoseEngineBlob &blob,
+                                         const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    auto &cache = blob.lookaround_cache;
+    vector<s8> look_offsets;
+    vector<vector<CharReach>> reaches;
+    for (const auto &vle : multi_look) {
+        reaches.push_back({});
+        bool done_offset = false;
+
+        for (const auto &le : vle) {
+            reaches.back().push_back(le.reach);
+
+            /* empty reaches don't have valid offsets */
+            if (!done_offset && le.reach.any()) {
+                look_offsets.push_back(le.offset);
+                done_offset = true;
+            }
+        }
+    }
+    inst->look_index = cache.get_offset_of(look_offsets, blob);
+    inst->reach_index = cache.get_offset_of(reaches, blob);
+    inst->count = verify_u32(multi_look.size());
+    inst->last_start = last_start;
+    copy(begin(start_mask), end(start_mask), inst->start_mask);
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckMultipathShufti16x8::write(void *dest, RoseEngineBlob &blob,
+                                          const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    copy(begin(nib_mask), end(nib_mask), inst->nib_mask);
+    copy(begin(bucket_select_mask), begin(bucket_select_mask) + 16,
+         inst->bucket_select_mask);
+    copy(begin(data_select_mask), begin(data_select_mask) + 16,
+         inst->data_select_mask);
+    inst->hi_bits_mask = hi_bits_mask;
+    inst->lo_bits_mask = lo_bits_mask;
+    inst->neg_mask = neg_mask;
+    inst->base_offset = base_offset;
+    inst->last_start = last_start;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckMultipathShufti32x8::write(void *dest, RoseEngineBlob &blob,
+                                          const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    copy(begin(hi_mask), begin(hi_mask) + 16, inst->hi_mask);
+    copy(begin(lo_mask), begin(lo_mask) + 16, inst->lo_mask);
+    copy(begin(bucket_select_mask), begin(bucket_select_mask) + 32,
+         inst->bucket_select_mask);
+    copy(begin(data_select_mask), begin(data_select_mask) + 32,
+         inst->data_select_mask);
+    inst->hi_bits_mask = hi_bits_mask;
+    inst->lo_bits_mask = lo_bits_mask;
+    inst->neg_mask = neg_mask;
+    inst->base_offset = base_offset;
+    inst->last_start = last_start;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckMultipathShufti32x16::write(void *dest, RoseEngineBlob &blob,
+                                           const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    copy(begin(hi_mask), end(hi_mask), inst->hi_mask);
+    copy(begin(lo_mask), end(lo_mask), inst->lo_mask);
+    copy(begin(bucket_select_mask_hi), begin(bucket_select_mask_hi) + 32,
+         inst->bucket_select_mask_hi);
+    copy(begin(bucket_select_mask_lo), begin(bucket_select_mask_lo) + 32,
+         inst->bucket_select_mask_lo);
+    copy(begin(data_select_mask), begin(data_select_mask) + 32,
+         inst->data_select_mask);
+    inst->hi_bits_mask = hi_bits_mask;
+    inst->lo_bits_mask = lo_bits_mask;
+    inst->neg_mask = neg_mask;
+    inst->base_offset = base_offset;
+    inst->last_start = last_start;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrCheckMultipathShufti64::write(void *dest, RoseEngineBlob &blob,
+                                            const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    copy(begin(hi_mask), begin(hi_mask) + 16, inst->hi_mask);
+    copy(begin(lo_mask), begin(lo_mask) + 16, inst->lo_mask);
+    copy(begin(bucket_select_mask), end(bucket_select_mask),
+         inst->bucket_select_mask);
+    copy(begin(data_select_mask), end(data_select_mask),
+         inst->data_select_mask);
+    inst->hi_bits_mask = hi_bits_mask;
+    inst->lo_bits_mask = lo_bits_mask;
+    inst->neg_mask = neg_mask;
+    inst->base_offset = base_offset;
+    inst->last_start = last_start;
+    inst->fail_jump = calc_jump(offset_map, this, target);
+}
+
+void RoseInstrIncludedJump::write(void *dest, RoseEngineBlob &blob,
+                                  const OffsetMap &offset_map) const {
+    RoseInstrBase::write(dest, blob, offset_map);
+    auto *inst = static_cast<impl_type *>(dest);
+    inst->child_offset = child_offset;
+    inst->squash = squash;
+}
+
 void RoseInstrSetLogical::write(void *dest, RoseEngineBlob &blob,
                                 const OffsetMap &offset_map) const {
     RoseInstrBase::write(dest, blob, offset_map);
     auto *inst = static_cast<impl_type *>(dest);
     inst->lkey = lkey;
     inst->offset_adjust = offset_adjust;
-} 
+}
 
 void RoseInstrSetCombination::write(void *dest, RoseEngineBlob &blob,
                                     const OffsetMap &offset_map) const {