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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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. ConstraintEliminationPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, globals: 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. ConstraintEliminationPass

----------------------------------------
define void @apply_delta(ptr nocapture noundef %dst, ptr nocapture nowrite noundef %src, i64 noundef %neg_offs, i64 noundef %count) nofree memory(argmem: readwrite, globals: 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. 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, globals: 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)

-- 39. 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, globals: 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)

-- 40. TailCallElimPass : Skipping unsupported
-- 41. TailCallElimPass : Skipping unsupported
-- 42. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 46. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 47. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 48. 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, globals: 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. PassManager<Function> : Skipping NOP
-- 50. 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, globals: 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. 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, globals: 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, globals: 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!

-- 52. 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, globals: 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)

-- 53. 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, globals: 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, globals: 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!

-- 54. PassManager<Function> : Skipping NOP
-- 55. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 56. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 67. 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, globals: 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)

-- 68. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 69. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 70. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 81. 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, globals: 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. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 83. 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, globals: 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)

-- 84. 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, globals: 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)

-- 85. 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, globals: 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, globals: 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!

-- 86. 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, globals: 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. 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, globals: 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)

-- 88. 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, globals: 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. PassManager<Function> : Skipping NOP
-- 90. 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, globals: 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)

-- 91. 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, globals: 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, globals: 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!

-- 92. 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, globals: 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)

-- 93. 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, globals: 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, globals: 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!

-- 94. PassManager<Function> : Skipping NOP
-- 95. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 96. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 103. 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, globals: 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)

-- 104. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 105. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 106. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 113. 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, globals: 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. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 115. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 122. 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, globals: 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)

-- 123. 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, globals: 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, globals: 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!

-- 124. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 130. 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, globals: 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)

-- 131. 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, globals: 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, globals: 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!

-- 132. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 140. 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, globals: 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. PassManager<Function> : Skipping NOP
-- 142. 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, globals: 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)

-- 143. 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, globals: 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, globals: 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!

-- 144. 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, globals: 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)

-- 145. 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, globals: 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, globals: 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!

-- 146. PassManager<Function> : Skipping NOP
-- 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, globals: 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 154. 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, globals: 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)

-- 155. 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, globals: 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, globals: 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!

-- 156. 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, globals: 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. 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, globals: 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)

-- 158. 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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. InvalidateAnalysisPass<ShouldNotRunFunctionPassesAnalysis> : Skipping NOP
-- 160. 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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, globals: 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. PassManager<Function> : Skipping NOP
-- 162. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 166. 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, globals: 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. PassManager<Function> : Skipping NOP
-- 168. 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, globals: 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)

-- 169. 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, globals: 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, globals: 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!

-- 170. 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, globals: 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)

-- 171. 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, globals: 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, globals: 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!

-- 172. PassManager<Function> : Skipping NOP
-- 173. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 174. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 177. 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, globals: 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)

-- 178. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 179. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 180. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 183. 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, globals: 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. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 185. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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. 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, globals: 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)

-- 190. 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, globals: 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)

-- 191. 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, globals: 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, globals: 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
  %8 = add i64 %index, 0
  %next.gep8 = gep ptr %src.addr.0.lcssa, 1 x i64 %8
  %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.end24 = sub i64 %count.addr.0.lcssa, %n.vec
  %ind.end21 = gep ptr %src.addr.0.lcssa, 1 x i64 %n.vec
  %ind.end18 = 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.vf15 = urem i64 %count.addr.0.lcssa, 8
  %n.vec16 = sub i64 %count.addr.0.lcssa, %n.mod.vf15
  %ind.end17 = gep ptr %dst.addr.0.lcssa, 1 x i64 %n.vec16
  %ind.end20 = gep ptr %src.addr.0.lcssa, 1 x i64 %n.vec16
  %ind.end23 = sub i64 %count.addr.0.lcssa, %n.vec16
  br label %vec.epilog.vector.body

%vec.epilog.vector.body:
  %index27 = phi i64 [ %vec.epilog.resume.val, %vec.epilog.ph ], [ %index.next32, %vec.epilog.vector.body ]
  %21 = add i64 %index27, 0
  %next.gep28 = gep ptr %dst.addr.0.lcssa, 1 x i64 %21
  %22 = add i64 %index27, 0
  %next.gep29 = gep ptr %src.addr.0.lcssa, 1 x i64 %22
  %23 = gep ptr %next.gep29, 1 x i32 0
  %wide.load30 = load <8 x i8>, ptr %23, align 1
  %24 = gep inbounds ptr %next.gep28, 1 x i64 noundef %neg_offs
  %25 = gep inbounds ptr %24, 1 x i32 0
  %wide.load31 = load <8 x i8>, ptr %25, align 1
  %26 = add <8 x i8> %wide.load31, %wide.load30
  %27 = gep ptr %next.gep28, 1 x i32 0
  store <8 x i8> %26, ptr %27, align 1
  %index.next32 = add nuw i64 %index27, 8
  %28 = icmp eq i64 %index.next32, %n.vec16
  br i1 %28, label %vec.epilog.middle.block, label %vec.epilog.vector.body

%vec.epilog.middle.block:
  %cmp.n26 = icmp eq i64 %count.addr.0.lcssa, %n.vec16
  br i1 %cmp.n26, label %while.end9.loopexit, label %vec.epilog.scalar.ph

%vec.epilog.scalar.ph:
  %bc.resume.val19 = phi ptr [ %ind.end17, %vec.epilog.middle.block ], [ %ind.end18, %vec.epilog.iter.check ], [ %dst.addr.0.lcssa, %vector.memcheck ], [ %dst.addr.0.lcssa, %iter.check ]
  %bc.resume.val22 = phi ptr [ %ind.end20, %vec.epilog.middle.block ], [ %ind.end21, %vec.epilog.iter.check ], [ %src.addr.0.lcssa, %vector.memcheck ], [ %src.addr.0.lcssa, %iter.check ]
  %bc.resume.val25 = phi i64 [ %ind.end23, %vec.epilog.middle.block ], [ %ind.end24, %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.val19, %vec.epilog.scalar.ph ]
  %src.addr.129 = phi ptr [ %incdec.ptr8, %while.body4 ], [ %bc.resume.val22, %vec.epilog.scalar.ph ]
  %count.addr.128 = phi i64 [ %dec, %while.body4 ], [ %bc.resume.val25, %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=4466232106225238008, attrs=1)
ptr nocapture nowrite noundef %src = pointer(non-local, block_id=2, offset=4, attrs=3)
i64 noundef %neg_offs = #x4200c18c00000007 (4756014013542825991)
i64 noundef %count = #x0000000000000009 (9)

Source:
i1 %cmp21 = #x1 (1)
  >> Jump to %while.body.preheader
  >> Jump to %while.body
ptr %dst.addr.024 = pointer(non-local, block_id=1, offset=4466232106225238008, attrs=1)
ptr %src.addr.023 = pointer(non-local, block_id=2, offset=4, attrs=3)
i64 %count.addr.022 = #x0000000000000009 (9)
<8 x i8> %0 = < poison, poison, poison, poison, poison, poison, poison, poison >
ptr %add.ptr = pointer(non-local, block_id=1, offset=9222246119768063999, attrs=1)
<8 x i8> %1 = < poison, poison, poison, poison, poison, poison, poison, poison >
<8 x i8> %add = < poison, poison, poison, poison, poison, poison, poison, poison >
ptr %add.ptr1 = pointer(non-local, block_id=1, offset=4466232106225238016, attrs=1)
ptr %add.ptr2 = pointer(non-local, block_id=2, offset=12, attrs=3)
i64 %sub = #x0000000000000001 (1)
i1 %cmp = #x0 (0)
  >> Jump to %while.cond3.preheader.loopexit
ptr %add.ptr1.lcssa = pointer(non-local, block_id=1, offset=4466232106225238016, attrs=1)
ptr %add.ptr2.lcssa = pointer(non-local, block_id=2, offset=12, attrs=3)
i64 %sub.lcssa = #x0000000000000001 (1)
  >> Jump to %while.cond3.preheader
i64 %count.addr.0.lcssa = #x0000000000000001 (1)
ptr %src.addr.0.lcssa = pointer(non-local, block_id=2, offset=12, attrs=3)
ptr %dst.addr.0.lcssa = pointer(non-local, block_id=1, offset=4466232106225238016, attrs=1)
i1 %tobool.not27 = #x0 (0)
  >> Jump to %while.body4.preheader
  >> Jump to %while.body4
ptr %dst.addr.130 = pointer(non-local, block_id=1, offset=4466232106225238016, attrs=1)
ptr %src.addr.129 = pointer(non-local, block_id=2, offset=12, attrs=3)
i64 %count.addr.128 = #x0000000000000001 (1)
i64 %dec = #x0000000000000000 (0)
i8 %2 = poison
ptr %arrayidx = pointer(non-local, block_id=1, offset=9222246119768064007, attrs=1)
i8 %3 = poison
i8 %add6 = poison
ptr %incdec.ptr = pointer(non-local, block_id=1, offset=4466232106225238017, attrs=1)
ptr %incdec.ptr8 = pointer(non-local, block_id=2, offset=13, attrs=3)
i1 %tobool.not = #x1 (1)
  >> Jump to %while.end9.loopexit
  >> Jump to %while.end9

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 1	alloc type: 0	address: 0
Block 1 >	size: 9223249097710895108	align: 2	alloc type: 0	address: 438108754231
Block 2 >	size: 18014398509481984	align: 2	alloc type: 0	address: 9351729046299870364

Target:
i1 %cmp21 = #x1 (1)
  >> Jump to %while.body.preheader
  >> Jump to %while.body
ptr %dst.addr.024 = pointer(non-local, block_id=1, offset=4466232106225238008, attrs=1)
ptr %src.addr.023 = pointer(non-local, block_id=2, offset=4, attrs=3)
i64 %count.addr.022 = #x0000000000000009 (9)
<8 x i8> %0 = < poison, poison, poison, poison, poison, poison, poison, poison >
ptr %add.ptr = pointer(non-local, block_id=1, offset=9222246119768063999, attrs=1)
<8 x i8> %1 = < poison, poison, poison, poison, poison, poison, poison, poison >
<8 x i8> %add = < poison, poison, poison, poison, poison, poison, poison, poison >
ptr %add.ptr1 = pointer(non-local, block_id=1, offset=4466232106225238016, attrs=1)
ptr %add.ptr2 = pointer(non-local, block_id=2, offset=12, attrs=3)
i64 %sub = #x0000000000000001 (1)
i1 %cmp = #x0 (0)
  >> Jump to %while.cond3.preheader.loopexit
ptr %add.ptr1.lcssa = pointer(non-local, block_id=1, offset=4466232106225238016, attrs=1)
ptr %add.ptr2.lcssa = pointer(non-local, block_id=2, offset=12, attrs=3)
i64 %sub.lcssa = #x0000000000000001 (1)
  >> Jump to %while.cond3.preheader
i64 %count.addr.0.lcssa = #x0000000000000001 (1)
ptr %src.addr.0.lcssa = pointer(non-local, block_id=2, offset=12, attrs=3)
ptr %dst.addr.0.lcssa = pointer(non-local, block_id=1, offset=4466232106225238016, 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'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_cFVCxom6_bHCF.bc"


------------------- SMT STATS -------------------
Num queries: 102
Num invalid: 0
Num skips:   0
Num trivial: 113 (52.6%)
Num timeout: 0 (0.0%)
Num errors:  0 (0.0%)
Num SAT:     94 (92.2%)
Num UNSAT:   8 (7.8%)
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