Test Failure: Transforms/PhaseOrdering/X86/pr38280.ll

Test source: git

Log:

Source: <stdin>
-- 1. Annotation2MetadataPass
-- 2. Annotation2MetadataPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 3. ForceFunctionAttrsPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 4. ForceFunctionAttrsPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 5. InferFunctionAttrsPass : Skipping unsupported
-- 6. InferFunctionAttrsPass : Skipping unsupported
-- 7. CoroEarlyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 8. CoroEarlyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 9. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 1. PassManager<Function> : Skipping NOP
-- 2. LowerExpectIntrinsicPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 3. LowerExpectIntrinsicPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 4. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 5. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 6. SROAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 7. SROAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 8. EarlyCSEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 9. EarlyCSEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 10. PassManager<Function> : Skipping NOP
-- 10. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 11. OpenMPOptPass : Skipping unsupported
-- 12. OpenMPOptPass : Skipping unsupported
-- 13. IPSCCPPass : Skipping unsupported
-- 14. IPSCCPPass : Skipping unsupported
-- 15. CalledValuePropagationPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 16. CalledValuePropagationPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 17. GlobalOptPass : Skipping unsupported
-- 18. GlobalOptPass : Skipping unsupported
-- 19. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 11. PromotePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 12. PromotePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 20. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 21. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 13. PassManager<Function> : Skipping NOP
-- 14. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 15. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 16. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 17. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 18. PassManager<Function> : Skipping NOP
-- 22. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 23. ModuleInlinerWrapperPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 24. RequireAnalysisPass<GlobalsAA, Module> : Skipping unsupported
-- 25. RequireAnalysisPass<GlobalsAA, Module> : Skipping unsupported
-- 26. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 19. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 20. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 27. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 28. RequireAnalysisPass<ProfileSummaryAnalysis, Module> : Skipping NOP
-- 29. RequireAnalysisPass<ProfileSummaryAnalysis, Module> : Skipping NOP
-- 30. ModuleToPostOrderCGSCCPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 31. DevirtSCCRepeatedPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 32. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 33. InlinerPass : Skipping unsupported
-- 34. InlinerPass : Skipping unsupported
-- 35. InlinerPass : Skipping unsupported
-- 36. InlinerPass : Skipping unsupported
-- 37. PostOrderFunctionAttrsPass : Skipping unsupported
-- 38. PostOrderFunctionAttrsPass : Skipping unsupported
-- 39. OpenMPOptCGSCCPass : Skipping unsupported
-- 40. OpenMPOptCGSCCPass : Skipping unsupported
-- 41. CGSCCToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 21. PassManager<Function> : Skipping NOP
-- 22. SROAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 23. SROAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 24. EarlyCSEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 25. EarlyCSEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 26. SpeculativeExecutionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 27. SpeculativeExecutionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 28. JumpThreadingPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 29. JumpThreadingPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 30. CorrelatedValuePropagationPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 31. CorrelatedValuePropagationPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 32. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 33. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 34. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 35. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 36. LibCallsShrinkWrapPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 37. LibCallsShrinkWrapPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 38. TailCallElimPass : Skipping unsupported
-- 39. TailCallElimPass : Skipping unsupported
-- 40. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 41. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 42. ReassociatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 43. ReassociatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 44. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 45. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 46. FunctionToLoopPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 47. PassManager<Function> : Skipping NOP
-- 48. LoopSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 49. LoopSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 50. LCSSAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 51. LCSSAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 54. LoopInstSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 55. LoopInstSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 56. LoopSimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 57. LoopSimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 58. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 59. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 60. LoopRotatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 61. LoopRotatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 62. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 63. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 64. SimpleLoopUnswitchPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 65. SimpleLoopUnswitchPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 66. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 67. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 68. LoopInstSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 69. LoopInstSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 70. LoopSimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 71. LoopSimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 72. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 73. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 74. LoopRotatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 75. LoopRotatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 76. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 77. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 78. SimpleLoopUnswitchPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 79. SimpleLoopUnswitchPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 80. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 81. FunctionToLoopPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 82. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 83. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 84. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 85. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 86. FunctionToLoopPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 87. PassManager<Function> : Skipping NOP
-- 88. LoopSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 89. LoopSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 90. LCSSAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 91. LCSSAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 94. LoopIdiomRecognizePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 95. LoopIdiomRecognizePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 96. IndVarSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 97. IndVarSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 98. LoopDeletionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 99. LoopDeletionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 100. LoopFullUnrollPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 101. LoopFullUnrollPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 102. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 103. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 104. LoopIdiomRecognizePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 105. LoopIdiomRecognizePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 106. IndVarSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 107. IndVarSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 108. LoopDeletionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 109. LoopDeletionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 110. LoopFullUnrollPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 111. LoopFullUnrollPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 112. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 113. FunctionToLoopPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 114. SROAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 115. SROAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 116. VectorCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 117. VectorCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 118. MergedLoadStoreMotionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 119. MergedLoadStoreMotionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 120. GVNPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 121. GVNPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 122. SCCPPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 123. SCCPPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 124. BDCEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 125. BDCEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 126. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 127. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 128. JumpThreadingPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 129. JumpThreadingPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 130. CorrelatedValuePropagationPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 131. CorrelatedValuePropagationPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 132. ADCEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 133. ADCEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 134. MemCpyOptPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 135. MemCpyOptPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 136. DSEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 137. DSEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 138. FunctionToLoopPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 139. PassManager<Function> : Skipping NOP
-- 140. LoopSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 141. LoopSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 142. LCSSAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 143. LCSSAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 144. PassManager<Function> : Skipping NOP
-- 145. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 146. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 147. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 148. LICMPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 149. FunctionToLoopPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 150. CoroElidePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 151. CoroElidePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 152. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 153. SimplifyCFGPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 154. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 155. InstCombinePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 156. PassManager<Function> : Skipping NOP
-- 42. CGSCCToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 43. CoroSplitPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 44. CoroSplitPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 45. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 46. DevirtSCCRepeatedPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 47. ModuleToPostOrderCGSCCPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 48. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 157. InvalidateAnalysisPass<ShouldNotRunFunctionPassesAnalysis> : Skipping NOP
-- 158. InvalidateAnalysisPass<ShouldNotRunFunctionPassesAnalysis> : Skipping NOP
-- 49. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 50. ModuleInlinerWrapperPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 51. DeadArgumentEliminationPass : Skipping unsupported
-- 52. DeadArgumentEliminationPass : Skipping unsupported
-- 53. CoroCleanupPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 54. CoroCleanupPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 55. GlobalOptPass : Skipping unsupported
-- 56. GlobalOptPass : Skipping unsupported
-- 57. GlobalDCEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 58. GlobalDCEPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 59. EliminateAvailableExternallyPass : Skipping unsupported
-- 60. EliminateAvailableExternallyPass : Skipping unsupported
-- 61. ReversePostOrderFunctionAttrsPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 62. ReversePostOrderFunctionAttrsPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 63. RecomputeGlobalsAAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 64. RecomputeGlobalsAAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 65. ModuleToFunctionPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 159. PassManager<Function> : Skipping NOP
-- 160. Float2IntPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 161. Float2IntPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 162. LowerConstantIntrinsicsPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 163. LowerConstantIntrinsicsPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 164. FunctionToLoopPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 165. PassManager<Function> : Skipping NOP
-- 166. LoopSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 167. LoopSimplifyPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body, label %while.cond3.preheader

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %entry ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %entry ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %entry ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.body ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.body ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.body ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.cond3.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.cond3.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.cond3.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9, label %while.body4

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 168. LCSSAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 169. LCSSAPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct!

-- 170. PassManager<Function> : Skipping NOP
-- 171. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 172. LoopRotatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 173. LoopRotatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 174. LoopDeletionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 175. LoopDeletionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 176. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 177. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 178. LoopRotatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 179. LoopRotatePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 180. LoopDeletionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 181. LoopDeletionPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 182. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 183. FunctionToLoopPassAdaptor

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 184. LoopDistributePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 185. LoopDistributePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 186. InjectTLIMappings

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 187. InjectTLIMappings

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 188. LoopVectorizePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 189. LoopVectorizePass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %while.body4.preheader

%while.body4.preheader:
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %dst.addr.0.lcssa, %while.body4.preheader ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %src.addr.0.lcssa, %while.body4.preheader ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %count.addr.0.lcssa, %while.body4.preheader ]
  %dec = add i64 %count.addr.128, -1
  %2 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %3 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %3, %2
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
=>
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, errno: readwrite, other: readwrite) {
%entry:
  %cmp21 = icmp ugt i64 noundef %count, 7
  br i1 %cmp21, label %while.body.preheader, label %while.cond3.preheader

%while.body.preheader:
  br label %while.body

%while.body:
  %dst.addr.024 = phi ptr [ %add.ptr1, %while.body ], [ nocapture noundef %dst, %while.body.preheader ]
  %src.addr.023 = phi ptr [ %add.ptr2, %while.body ], [ nocapture nowrite noundef %src, %while.body.preheader ]
  %count.addr.022 = phi i64 [ %sub, %while.body ], [ noundef %count, %while.body.preheader ]
  %0 = load <8 x i8>, ptr %src.addr.023, align 1
  %add.ptr = gep inbounds ptr %dst.addr.024, 1 x i64 noundef %neg_offs
  %1 = load <8 x i8>, ptr %add.ptr, align 1
  %add = add <8 x i8> %1, %0
  store <8 x i8> %add, ptr %dst.addr.024, align 1
  %add.ptr1 = gep inbounds ptr %dst.addr.024, 1 x i64 8
  %add.ptr2 = gep inbounds ptr %src.addr.023, 1 x i64 8
  %sub = add i64 %count.addr.022, -8
  %cmp = icmp ugt i64 %sub, 7
  br i1 %cmp, label %while.body, label %while.cond3.preheader.loopexit

%while.cond3.preheader.loopexit:
  %add.ptr1.lcssa = phi ptr [ %add.ptr1, %while.body ]
  %add.ptr2.lcssa = phi ptr [ %add.ptr2, %while.body ]
  %sub.lcssa = phi i64 [ %sub, %while.body ]
  br label %while.cond3.preheader

%while.cond3.preheader:
  %count.addr.0.lcssa = phi i64 [ noundef %count, %entry ], [ %sub.lcssa, %while.cond3.preheader.loopexit ]
  %src.addr.0.lcssa = phi ptr [ nocapture nowrite noundef %src, %entry ], [ %add.ptr2.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa = phi ptr [ nocapture noundef %dst, %entry ], [ %add.ptr1.lcssa, %while.cond3.preheader.loopexit ]
  %dst.addr.0.lcssa1 = ptrtoint ptr %dst.addr.0.lcssa to i64
  %src.addr.0.lcssa2 = ptrtoint ptr %src.addr.0.lcssa to i64
  %tobool.not27 = icmp eq i64 %count.addr.0.lcssa, 0
  br i1 %tobool.not27, label %while.end9, label %iter.check

%iter.check:
  %min.iters.check = icmp ult i64 %count.addr.0.lcssa, 8
  br i1 %min.iters.check, label %vec.epilog.scalar.ph, label %vector.memcheck

%vector.memcheck:
  %2 = sub i64 %dst.addr.0.lcssa1, %src.addr.0.lcssa2
  %diff.check = icmp ult i64 %2, 32
  %3 = sub i64 %dst.addr.0.lcssa1, %src.addr.0.lcssa2
  %diff.check3 = icmp ult i64 %3, 32
  %conflict.rdx = or i1 %diff.check, %diff.check3
  %4 = add i64 noundef %neg_offs, %dst.addr.0.lcssa1
  %5 = sub i64 %dst.addr.0.lcssa1, %4
  %diff.check4 = icmp ult i64 %5, 32
  %conflict.rdx5 = or i1 %conflict.rdx, %diff.check4
  br i1 %conflict.rdx5, label %vec.epilog.scalar.ph, label %vector.main.loop.iter.check

%vector.main.loop.iter.check:
  %min.iters.check6 = icmp ult i64 %count.addr.0.lcssa, 32
  br i1 %min.iters.check6, label %vec.epilog.ph, label %vector.ph

%vector.ph:
  %n.mod.vf = urem i64 %count.addr.0.lcssa, 32
  %n.vec = sub i64 %count.addr.0.lcssa, %n.mod.vf
  br label %vector.body

%vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %6 = add i64 %index, 0
  %next.gep = gep ptr %dst.addr.0.lcssa, 1 x i64 %6
  %7 = add i64 %index, 16
  %8 = add i64 %index, 0
  %next.gep8 = gep ptr %src.addr.0.lcssa, 1 x i64 %8
  %9 = add i64 %index, 16
  %10 = gep ptr %next.gep8, 1 x i32 0
  %wide.load = load <16 x i8>, ptr %10, align 1
  %11 = gep ptr %next.gep8, 1 x i32 16
  %wide.load10 = load <16 x i8>, ptr %11, align 1
  %12 = gep inbounds ptr %next.gep, 1 x i64 noundef %neg_offs
  %14 = gep inbounds ptr %12, 1 x i32 0
  %wide.load11 = load <16 x i8>, ptr %14, align 1
  %15 = gep inbounds ptr %12, 1 x i32 16
  %wide.load12 = load <16 x i8>, ptr %15, align 1
  %16 = add <16 x i8> %wide.load11, %wide.load
  %17 = add <16 x i8> %wide.load12, %wide.load10
  %18 = gep ptr %next.gep, 1 x i32 0
  store <16 x i8> %16, ptr %18, align 1
  %19 = gep ptr %next.gep, 1 x i32 16
  store <16 x i8> %17, ptr %19, align 1
  %index.next = add nuw i64 %index, 32
  %20 = icmp eq i64 %index.next, %n.vec
  br i1 %20, label %middle.block, label %vector.body

%middle.block:
  %cmp.n = icmp eq i64 %count.addr.0.lcssa, %n.vec
  br i1 %cmp.n, label %while.end9.loopexit, label %vec.epilog.iter.check

%vec.epilog.iter.check:
  %ind.end20 = sub i64 %count.addr.0.lcssa, %n.vec
  %ind.end17 = gep ptr %src.addr.0.lcssa, 1 x i64 %n.vec
  %ind.end15 = gep ptr %dst.addr.0.lcssa, 1 x i64 %n.vec
  %n.vec.remaining = sub i64 %count.addr.0.lcssa, %n.vec
  %min.epilog.iters.check = icmp ult i64 %n.vec.remaining, 8
  br i1 %min.epilog.iters.check, label %vec.epilog.scalar.ph, label %vec.epilog.ph

%vec.epilog.ph:
  %vec.epilog.resume.val = phi i64 [ %n.vec, %vec.epilog.iter.check ], [ 0, %vector.main.loop.iter.check ]
  %n.mod.vf13 = urem i64 %count.addr.0.lcssa, 8
  %n.vec14 = sub i64 %count.addr.0.lcssa, %n.mod.vf13
  %ind.end = gep ptr %dst.addr.0.lcssa, 1 x i64 %n.vec14
  %ind.end16 = gep ptr %src.addr.0.lcssa, 1 x i64 %n.vec14
  %ind.end19 = sub i64 %count.addr.0.lcssa, %n.vec14
  br label %vec.epilog.vector.body

%vec.epilog.vector.body:
  %index23 = phi i64 [ %vec.epilog.resume.val, %vec.epilog.ph ], [ %index.next28, %vec.epilog.vector.body ]
  %21 = add i64 %index23, 0
  %next.gep24 = gep ptr %dst.addr.0.lcssa, 1 x i64 %21
  %22 = add i64 %index23, 0
  %next.gep25 = gep ptr %src.addr.0.lcssa, 1 x i64 %22
  %23 = gep ptr %next.gep25, 1 x i32 0
  %wide.load26 = load <8 x i8>, ptr %23, align 1
  %24 = gep inbounds ptr %next.gep24, 1 x i64 noundef %neg_offs
  %25 = gep inbounds ptr %24, 1 x i32 0
  %wide.load27 = load <8 x i8>, ptr %25, align 1
  %26 = add <8 x i8> %wide.load27, %wide.load26
  %27 = gep ptr %next.gep24, 1 x i32 0
  store <8 x i8> %26, ptr %27, align 1
  %index.next28 = add nuw i64 %index23, 8
  %28 = icmp eq i64 %index.next28, %n.vec14
  br i1 %28, label %vec.epilog.middle.block, label %vec.epilog.vector.body

%vec.epilog.middle.block:
  %cmp.n22 = icmp eq i64 %count.addr.0.lcssa, %n.vec14
  br i1 %cmp.n22, label %while.end9.loopexit, label %vec.epilog.scalar.ph

%vec.epilog.scalar.ph:
  %bc.resume.val = phi ptr [ %ind.end, %vec.epilog.middle.block ], [ %ind.end15, %vec.epilog.iter.check ], [ %dst.addr.0.lcssa, %vector.memcheck ], [ %dst.addr.0.lcssa, %iter.check ]
  %bc.resume.val18 = phi ptr [ %ind.end16, %vec.epilog.middle.block ], [ %ind.end17, %vec.epilog.iter.check ], [ %src.addr.0.lcssa, %vector.memcheck ], [ %src.addr.0.lcssa, %iter.check ]
  %bc.resume.val21 = phi i64 [ %ind.end19, %vec.epilog.middle.block ], [ %ind.end20, %vec.epilog.iter.check ], [ %count.addr.0.lcssa, %vector.memcheck ], [ %count.addr.0.lcssa, %iter.check ]
  br label %while.body4

%while.body4:
  %dst.addr.130 = phi ptr [ %incdec.ptr, %while.body4 ], [ %bc.resume.val, %vec.epilog.scalar.ph ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %bc.resume.val18, %vec.epilog.scalar.ph ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %bc.resume.val21, %vec.epilog.scalar.ph ]
  %dec = add i64 %count.addr.128, -1
  %29 = load i8, ptr %src.addr.129, align 1
  %arrayidx = gep inbounds ptr %dst.addr.130, 1 x i64 noundef %neg_offs
  %30 = load i8, ptr %arrayidx, align 1
  %add6 = add i8 %30, %29
  store i8 %add6, ptr %dst.addr.130, align 1
  %incdec.ptr = gep inbounds ptr %dst.addr.130, 1 x i64 1
  %incdec.ptr8 = gep inbounds ptr %src.addr.129, 1 x i64 1
  %tobool.not = icmp eq i64 %dec, 0
  br i1 %tobool.not, label %while.end9.loopexit, label %while.body4

%while.end9.loopexit:
  br label %while.end9

%while.end9:
  ret void
}
Transformation doesn't verify! (unsound)
ERROR: Source is more defined than target

Example:
ptr nocapture noundef %dst = pointer(non-local, block_id=1, offset=-2, attrs=1)
ptr nocapture nowrite noundef %src = pointer(non-local, block_id=2, offset=-2, attrs=3)
i64 noundef %neg_offs = #xfffffffffffffffe (18446744073709551614, -2)
i64 noundef %count = #x0000000000000000 (0)

Source:
i1 %cmp21 = #x0 (0)
  >> Jump to %while.cond3.preheader
i64 %count.addr.0.lcssa = #x0000000000000000 (0)
ptr %src.addr.0.lcssa = pointer(non-local, block_id=2, offset=-2, attrs=3)
ptr %dst.addr.0.lcssa = pointer(non-local, block_id=1, offset=-2, attrs=1)
i1 %tobool.not27 = #x1 (1)
  >> Jump to %while.end9

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 1	alloc type: 0	address: 0
Block 1 >	size: 4611686018427387904	align: 2	alloc type: 0	address: 6917810502907268097
Block 2 >	size: 4611686018427387904	align: 4	alloc type: 0	address: 1153211775953472000

Target:
i1 %cmp21 = #x0 (0)
  >> Jump to %while.cond3.preheader
i64 %count.addr.0.lcssa = #x0000000000000000 (0)
ptr %src.addr.0.lcssa = pointer(non-local, block_id=2, offset=-2, attrs=3)
ptr %dst.addr.0.lcssa = pointer(non-local, block_id=1, offset=-2, attrs=1)
i64 %dst.addr.0.lcssa1 = UB triggered!


Pass: LoopVectorizePass
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-O2' '-S' '-mtriple=x86_64--' '-mattr=+sse2' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'


------------------- SMT STATS -------------------
Num queries: 43
Num invalid: 0
Num skips:   0
Num trivial: 91 (67.9%)
Num timeout: 0 (0.0%)
Num errors:  0 (0.0%)
Num SAT:     43 (100.0%)
Num UNSAT:   0 (0.0%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -O2 -S -mtriple=x86_64-- -mattr=+sse2
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/PhaseOrdering/X86/pr38280.ll

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/PhaseOrdering/X86/pr38280.ll

<-- Back